Blender V5.0
vk_data_conversion.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "vk_data_conversion.hh"
10
11#include "BLI_color.hh"
12#include "BLI_math_half.hh"
13
14namespace blender::gpu {
15
16/* -------------------------------------------------------------------- */
19
78
79static ConversionType type_of_conversion_float(const TextureFormat host_format,
80 const TextureFormat device_format)
81{
82 if (host_format != device_format) {
83 if (host_format == TextureFormat::SFLOAT_16_16_16 &&
84 device_format == TextureFormat::SFLOAT_16_16_16_16)
85 {
86 return ConversionType::FLOAT3_TO_HALF4;
87 }
88 if (host_format == TextureFormat::SFLOAT_32_32_32 &&
89 device_format == TextureFormat::SFLOAT_32_32_32_32)
90 {
91 return ConversionType::FLOAT3_TO_FLOAT4;
92 }
93
94 return ConversionType::UNSUPPORTED;
95 }
96
97 switch (device_format) {
98 case TextureFormat::SFLOAT_32_32_32_32:
99 case TextureFormat::SFLOAT_32_32:
100 case TextureFormat::SFLOAT_32:
101 case TextureFormat::SFLOAT_32_DEPTH:
102 return ConversionType::PASS_THROUGH;
103
104 case TextureFormat::SFLOAT_32_DEPTH_UINT_8:
105 return ConversionType::PASS_THROUGH_D32F_S8;
106
107 case TextureFormat::SFLOAT_16_16_16_16:
108 case TextureFormat::SFLOAT_16_16:
109 case TextureFormat::SFLOAT_16:
110 case TextureFormat::SFLOAT_16_16_16:
111 return ConversionType::FLOAT_TO_HALF;
112
113 case TextureFormat::SRGBA_8_8_8_8:
114 case TextureFormat::UNORM_8_8_8_8:
115 case TextureFormat::UNORM_8_8:
116 case TextureFormat::UNORM_8:
117 return ConversionType::FLOAT_TO_UNORM8;
118
119 case TextureFormat::SNORM_8_8_8_8:
120 case TextureFormat::SNORM_8_8_8:
121 case TextureFormat::SNORM_8_8:
122 case TextureFormat::SNORM_8:
123 return ConversionType::FLOAT_TO_SNORM8;
124
125 case TextureFormat::UNORM_16_16_16_16:
126 case TextureFormat::UNORM_16_16:
127 case TextureFormat::UNORM_16:
128 return ConversionType::FLOAT_TO_UNORM16;
129
130 case TextureFormat::SNORM_16_16_16_16:
131 case TextureFormat::SNORM_16_16_16:
132 case TextureFormat::SNORM_16_16:
133 case TextureFormat::SNORM_16:
134 return ConversionType::FLOAT_TO_SNORM16;
135
136 case TextureFormat::UFLOAT_11_11_10:
137 return ConversionType::FLOAT_TO_B10F_G11F_R11F;
138
139 case TextureFormat::SRGB_DXT1:
140 case TextureFormat::SRGB_DXT3:
141 case TextureFormat::SRGB_DXT5:
142 case TextureFormat::SNORM_DXT1:
143 case TextureFormat::SNORM_DXT3:
144 case TextureFormat::SNORM_DXT5:
145 /* Not an actual "conversion", but compressed texture upload code
146 * pretends that host data is a float. It is actually raw BCn bits. */
147 return ConversionType::PASS_THROUGH;
148
149 /* #TextureFormat::SFLOAT_32_32_32 Not supported by vendors. */
150 case TextureFormat::SFLOAT_32_32_32:
151
152 case TextureFormat::UINT_8_8_8_8:
153 case TextureFormat::SINT_8_8_8_8:
154 case TextureFormat::UINT_16_16_16_16:
155 case TextureFormat::SINT_16_16_16_16:
156 case TextureFormat::UINT_32_32_32_32:
157 case TextureFormat::SINT_32_32_32_32:
158 case TextureFormat::UINT_8_8:
159 case TextureFormat::SINT_8_8:
160 case TextureFormat::UINT_16_16:
161 case TextureFormat::SINT_16_16:
162 case TextureFormat::UINT_32_32:
163 case TextureFormat::SINT_32_32:
164 case TextureFormat::UINT_8:
165 case TextureFormat::SINT_8:
166 case TextureFormat::UINT_16:
167 case TextureFormat::SINT_16:
168 case TextureFormat::UINT_32:
169 case TextureFormat::SINT_32:
170 case TextureFormat::UNORM_10_10_10_2:
171 case TextureFormat::UINT_10_10_10_2:
172 case TextureFormat::UINT_8_8_8:
173 case TextureFormat::SINT_8_8_8:
174 case TextureFormat::UNORM_8_8_8:
175 case TextureFormat::UINT_16_16_16:
176 case TextureFormat::SINT_16_16_16:
177 case TextureFormat::UNORM_16_16_16:
178 case TextureFormat::UINT_32_32_32:
179 case TextureFormat::SINT_32_32_32:
180 case TextureFormat::SRGBA_8_8_8:
181 case TextureFormat::UFLOAT_9_9_9_EXP_5:
182 case TextureFormat::UNORM_16_DEPTH:
183 return ConversionType::UNSUPPORTED;
184
185 case TextureFormat::Invalid:
186 BLI_assert_unreachable();
187 break;
188 }
189 return ConversionType::UNSUPPORTED;
190}
191
192static ConversionType type_of_conversion_int(TextureFormat device_format)
193{
194 switch (device_format) {
195 case TextureFormat::SINT_32_32_32_32:
196 case TextureFormat::SINT_32_32:
197 case TextureFormat::SINT_32:
198 return ConversionType::PASS_THROUGH;
199
200 case TextureFormat::SINT_16_16_16_16:
201 case TextureFormat::SINT_16_16:
202 case TextureFormat::SINT_16:
203 return ConversionType::I32_TO_I16;
204
205 case TextureFormat::SINT_8_8_8_8:
206 case TextureFormat::SINT_8_8:
207 case TextureFormat::SINT_8:
208 return ConversionType::I32_TO_I8;
209
210 case TextureFormat::UINT_8_8_8_8:
211 case TextureFormat::UNORM_8_8_8_8:
212 case TextureFormat::UINT_16_16_16_16:
213 case TextureFormat::SFLOAT_16_16_16_16:
214 case TextureFormat::UNORM_16_16_16_16:
215 case TextureFormat::UINT_32_32_32_32:
216 case TextureFormat::SFLOAT_32_32_32_32:
217 case TextureFormat::UINT_8_8:
218 case TextureFormat::UNORM_8_8:
219 case TextureFormat::UINT_16_16:
220 case TextureFormat::SFLOAT_16_16:
221 case TextureFormat::UINT_32_32:
222 case TextureFormat::SFLOAT_32_32:
223 case TextureFormat::UNORM_16_16:
224 case TextureFormat::UINT_8:
225 case TextureFormat::UNORM_8:
226 case TextureFormat::UINT_16:
227 case TextureFormat::SFLOAT_16:
228 case TextureFormat::UNORM_16:
229 case TextureFormat::UINT_32:
230 case TextureFormat::SFLOAT_32:
231 case TextureFormat::UNORM_10_10_10_2:
232 case TextureFormat::UINT_10_10_10_2:
233 case TextureFormat::UFLOAT_11_11_10:
234 case TextureFormat::SFLOAT_32_DEPTH_UINT_8:
235 case TextureFormat::SRGBA_8_8_8_8:
236 case TextureFormat::SNORM_8_8_8_8:
237 case TextureFormat::SNORM_16_16_16_16:
238 case TextureFormat::UINT_8_8_8:
239 case TextureFormat::SINT_8_8_8:
240 case TextureFormat::UNORM_8_8_8:
241 case TextureFormat::SNORM_8_8_8:
242 case TextureFormat::UINT_16_16_16:
243 case TextureFormat::SINT_16_16_16:
244 case TextureFormat::SFLOAT_16_16_16:
245 case TextureFormat::UNORM_16_16_16:
246 case TextureFormat::SNORM_16_16_16:
247 case TextureFormat::UINT_32_32_32:
248 case TextureFormat::SINT_32_32_32:
249 case TextureFormat::SFLOAT_32_32_32:
250 case TextureFormat::SNORM_8_8:
251 case TextureFormat::SNORM_16_16:
252 case TextureFormat::SNORM_8:
253 case TextureFormat::SNORM_16:
254 case TextureFormat::SRGB_DXT1:
255 case TextureFormat::SRGB_DXT3:
256 case TextureFormat::SRGB_DXT5:
257 case TextureFormat::SNORM_DXT1:
258 case TextureFormat::SNORM_DXT3:
259 case TextureFormat::SNORM_DXT5:
260 case TextureFormat::SRGBA_8_8_8:
261 case TextureFormat::UFLOAT_9_9_9_EXP_5:
262 case TextureFormat::SFLOAT_32_DEPTH:
263 case TextureFormat::UNORM_16_DEPTH:
264 return ConversionType::UNSUPPORTED;
265
266 case TextureFormat::Invalid:
267 BLI_assert_unreachable();
268 break;
269 }
270 return ConversionType::UNSUPPORTED;
271}
272
273static ConversionType type_of_conversion_uint(TextureFormat device_format)
274{
275 switch (device_format) {
276 case TextureFormat::UINT_32_32_32_32:
277 case TextureFormat::UINT_32_32:
278 case TextureFormat::UINT_32:
279 return ConversionType::PASS_THROUGH;
280
281 case TextureFormat::UINT_16_16_16_16:
282 case TextureFormat::UINT_16_16:
283 case TextureFormat::UINT_16:
284 case TextureFormat::UINT_16_16_16:
285 return ConversionType::UI32_TO_UI16;
286
287 case TextureFormat::UINT_8_8_8_8:
288 case TextureFormat::UINT_8_8:
289 case TextureFormat::UINT_8:
290 return ConversionType::UI32_TO_UI8;
291
292 case TextureFormat::SFLOAT_32_DEPTH:
293 case TextureFormat::SFLOAT_32_DEPTH_UINT_8:
294 return ConversionType::UNORM32_TO_FLOAT;
295
296 case TextureFormat::SINT_8_8_8_8:
297 case TextureFormat::UNORM_8_8_8_8:
298 case TextureFormat::SINT_16_16_16_16:
299 case TextureFormat::SFLOAT_16_16_16_16:
300 case TextureFormat::UNORM_16_16_16_16:
301 case TextureFormat::SINT_32_32_32_32:
302 case TextureFormat::SFLOAT_32_32_32_32:
303 case TextureFormat::SINT_8_8:
304 case TextureFormat::UNORM_8_8:
305 case TextureFormat::SINT_16_16:
306 case TextureFormat::SFLOAT_16_16:
307 case TextureFormat::UNORM_16_16:
308 case TextureFormat::SINT_32_32:
309 case TextureFormat::SFLOAT_32_32:
310 case TextureFormat::SINT_8:
311 case TextureFormat::UNORM_8:
312 case TextureFormat::SINT_16:
313 case TextureFormat::SFLOAT_16:
314 case TextureFormat::UNORM_16:
315 case TextureFormat::SINT_32:
316 case TextureFormat::SFLOAT_32:
317 case TextureFormat::UNORM_10_10_10_2:
318 case TextureFormat::UINT_10_10_10_2:
319 case TextureFormat::UFLOAT_11_11_10:
320 case TextureFormat::SRGBA_8_8_8_8:
321 case TextureFormat::SNORM_8_8_8_8:
322 case TextureFormat::SNORM_16_16_16_16:
323 case TextureFormat::UINT_8_8_8:
324 case TextureFormat::SINT_8_8_8:
325 case TextureFormat::UNORM_8_8_8:
326 case TextureFormat::SNORM_8_8_8:
327 case TextureFormat::SINT_16_16_16:
328 case TextureFormat::SFLOAT_16_16_16:
329 case TextureFormat::UNORM_16_16_16:
330 case TextureFormat::SNORM_16_16_16:
331 case TextureFormat::UINT_32_32_32:
332 case TextureFormat::SINT_32_32_32:
333 case TextureFormat::SFLOAT_32_32_32:
334 case TextureFormat::SNORM_8_8:
335 case TextureFormat::SNORM_16_16:
336 case TextureFormat::SNORM_8:
337 case TextureFormat::SNORM_16:
338 case TextureFormat::SRGB_DXT1:
339 case TextureFormat::SRGB_DXT3:
340 case TextureFormat::SRGB_DXT5:
341 case TextureFormat::SNORM_DXT1:
342 case TextureFormat::SNORM_DXT3:
343 case TextureFormat::SNORM_DXT5:
344 case TextureFormat::SRGBA_8_8_8:
345 case TextureFormat::UFLOAT_9_9_9_EXP_5:
346 case TextureFormat::UNORM_16_DEPTH:
347 return ConversionType::UNSUPPORTED;
348
349 case TextureFormat::Invalid:
350 BLI_assert_unreachable();
351 break;
352 }
353 return ConversionType::UNSUPPORTED;
354}
355
356static ConversionType type_of_conversion_half(TextureFormat device_format)
357{
358 switch (device_format) {
359 case TextureFormat::SFLOAT_16_16_16_16:
360 case TextureFormat::SFLOAT_16_16:
361 case TextureFormat::SFLOAT_16:
362 return ConversionType::PASS_THROUGH;
363
364 case TextureFormat::UINT_8_8_8_8:
365 case TextureFormat::SINT_8_8_8_8:
366 case TextureFormat::UNORM_8_8_8_8:
367 case TextureFormat::UINT_16_16_16_16:
368 case TextureFormat::SINT_16_16_16_16:
369 case TextureFormat::UNORM_16_16_16_16:
370 case TextureFormat::UINT_32_32_32_32:
371 case TextureFormat::SINT_32_32_32_32:
372 case TextureFormat::SFLOAT_32_32_32_32:
373 case TextureFormat::UINT_8_8:
374 case TextureFormat::SINT_8_8:
375 case TextureFormat::UNORM_8_8:
376 case TextureFormat::UINT_16_16:
377 case TextureFormat::SINT_16_16:
378 case TextureFormat::UNORM_16_16:
379 case TextureFormat::UINT_32_32:
380 case TextureFormat::SINT_32_32:
381 case TextureFormat::SFLOAT_32_32:
382 case TextureFormat::UINT_8:
383 case TextureFormat::SINT_8:
384 case TextureFormat::UNORM_8:
385 case TextureFormat::UINT_16:
386 case TextureFormat::SINT_16:
387 case TextureFormat::UNORM_16:
388 case TextureFormat::UINT_32:
389 case TextureFormat::SINT_32:
390 case TextureFormat::SFLOAT_32:
391 case TextureFormat::UNORM_10_10_10_2:
392 case TextureFormat::UINT_10_10_10_2:
393 case TextureFormat::UFLOAT_11_11_10:
394 case TextureFormat::SFLOAT_32_DEPTH_UINT_8:
395 case TextureFormat::SRGBA_8_8_8_8:
396 case TextureFormat::SNORM_8_8_8_8:
397 case TextureFormat::SNORM_16_16_16_16:
398 case TextureFormat::UINT_8_8_8:
399 case TextureFormat::SINT_8_8_8:
400 case TextureFormat::UNORM_8_8_8:
401 case TextureFormat::SNORM_8_8_8:
402 case TextureFormat::UINT_16_16_16:
403 case TextureFormat::SINT_16_16_16:
404 case TextureFormat::SFLOAT_16_16_16:
405 case TextureFormat::UNORM_16_16_16:
406 case TextureFormat::SNORM_16_16_16:
407 case TextureFormat::UINT_32_32_32:
408 case TextureFormat::SINT_32_32_32:
409 case TextureFormat::SFLOAT_32_32_32:
410 case TextureFormat::SNORM_8_8:
411 case TextureFormat::SNORM_16_16:
412 case TextureFormat::SNORM_8:
413 case TextureFormat::SNORM_16:
414 case TextureFormat::SRGB_DXT1:
415 case TextureFormat::SRGB_DXT3:
416 case TextureFormat::SRGB_DXT5:
417 case TextureFormat::SNORM_DXT1:
418 case TextureFormat::SNORM_DXT3:
419 case TextureFormat::SNORM_DXT5:
420 case TextureFormat::SRGBA_8_8_8:
421 case TextureFormat::UFLOAT_9_9_9_EXP_5:
422 case TextureFormat::SFLOAT_32_DEPTH:
423 case TextureFormat::UNORM_16_DEPTH:
424 return ConversionType::UNSUPPORTED;
425
426 case TextureFormat::Invalid:
427 BLI_assert_unreachable();
428 break;
429 }
430 return ConversionType::UNSUPPORTED;
431}
432
433static ConversionType type_of_conversion_ubyte(TextureFormat device_format)
434{
435 switch (device_format) {
436 case TextureFormat::UINT_8_8_8_8:
437 case TextureFormat::UNORM_8_8_8_8:
438 case TextureFormat::UINT_8_8:
439 case TextureFormat::UNORM_8_8:
440 case TextureFormat::UINT_8:
441 case TextureFormat::UNORM_8:
442 case TextureFormat::SRGBA_8_8_8_8:
443 return ConversionType::PASS_THROUGH;
444
445 case TextureFormat::SFLOAT_16_16_16_16:
446 case TextureFormat::SFLOAT_16_16:
447 case TextureFormat::SFLOAT_16:
448 return ConversionType::UI8_TO_HALF;
449
450 case TextureFormat::SINT_8_8_8_8:
451 case TextureFormat::UINT_16_16_16_16:
452 case TextureFormat::SINT_16_16_16_16:
453 case TextureFormat::UNORM_16_16_16_16:
454 case TextureFormat::UINT_32_32_32_32:
455 case TextureFormat::SINT_32_32_32_32:
456 case TextureFormat::SFLOAT_32_32_32_32:
457 case TextureFormat::SINT_8_8:
458 case TextureFormat::UINT_16_16:
459 case TextureFormat::SINT_16_16:
460 case TextureFormat::UNORM_16_16:
461 case TextureFormat::UINT_32_32:
462 case TextureFormat::SINT_32_32:
463 case TextureFormat::SFLOAT_32_32:
464 case TextureFormat::SINT_8:
465 case TextureFormat::UINT_16:
466 case TextureFormat::SINT_16:
467 case TextureFormat::UNORM_16:
468 case TextureFormat::UINT_32:
469 case TextureFormat::SINT_32:
470 case TextureFormat::SFLOAT_32:
471 case TextureFormat::UNORM_10_10_10_2:
472 case TextureFormat::UINT_10_10_10_2:
473 case TextureFormat::UFLOAT_11_11_10:
474 case TextureFormat::SFLOAT_32_DEPTH_UINT_8:
475 case TextureFormat::SNORM_8_8_8_8:
476 case TextureFormat::SNORM_16_16_16_16:
477 case TextureFormat::UINT_8_8_8:
478 case TextureFormat::SINT_8_8_8:
479 case TextureFormat::UNORM_8_8_8:
480 case TextureFormat::SNORM_8_8_8:
481 case TextureFormat::UINT_16_16_16:
482 case TextureFormat::SINT_16_16_16:
483 case TextureFormat::SFLOAT_16_16_16:
484 case TextureFormat::UNORM_16_16_16:
485 case TextureFormat::SNORM_16_16_16:
486 case TextureFormat::UINT_32_32_32:
487 case TextureFormat::SINT_32_32_32:
488 case TextureFormat::SFLOAT_32_32_32:
489 case TextureFormat::SNORM_8_8:
490 case TextureFormat::SNORM_16_16:
491 case TextureFormat::SNORM_8:
492 case TextureFormat::SNORM_16:
493 case TextureFormat::SRGB_DXT1:
494 case TextureFormat::SRGB_DXT3:
495 case TextureFormat::SRGB_DXT5:
496 case TextureFormat::SNORM_DXT1:
497 case TextureFormat::SNORM_DXT3:
498 case TextureFormat::SNORM_DXT5:
499 case TextureFormat::SRGBA_8_8_8:
500 case TextureFormat::UFLOAT_9_9_9_EXP_5:
501 case TextureFormat::SFLOAT_32_DEPTH:
502 case TextureFormat::UNORM_16_DEPTH:
503 return ConversionType::UNSUPPORTED;
504
505 case TextureFormat::Invalid:
506 BLI_assert_unreachable();
507 break;
508 }
509 return ConversionType::UNSUPPORTED;
510}
511
512static ConversionType type_of_conversion_uint248(const TextureFormat device_format)
513{
514 switch (device_format) {
515 case TextureFormat::SFLOAT_32_DEPTH_UINT_8:
516 return ConversionType::UINT_TO_DEPTH32F_STENCIL8;
517
518 case TextureFormat::SFLOAT_32_32_32_32:
519 case TextureFormat::SFLOAT_32_32:
520 case TextureFormat::SFLOAT_32:
521 case TextureFormat::SFLOAT_16_16_16_16:
522 case TextureFormat::SFLOAT_16_16:
523 case TextureFormat::SFLOAT_16:
524 case TextureFormat::SFLOAT_16_16_16:
525 case TextureFormat::UNORM_8_8_8_8:
526 case TextureFormat::UNORM_8_8:
527 case TextureFormat::UNORM_8:
528 case TextureFormat::SNORM_8_8_8_8:
529 case TextureFormat::SNORM_8_8_8:
530 case TextureFormat::SNORM_8_8:
531 case TextureFormat::SNORM_8:
532 case TextureFormat::UNORM_16_16_16_16:
533 case TextureFormat::UNORM_16_16:
534 case TextureFormat::UNORM_16:
535 case TextureFormat::SNORM_16_16_16_16:
536 case TextureFormat::SNORM_16_16_16:
537 case TextureFormat::SNORM_16_16:
538 case TextureFormat::SNORM_16:
539 case TextureFormat::SRGBA_8_8_8_8:
540 case TextureFormat::SFLOAT_32_DEPTH:
541 case TextureFormat::UFLOAT_11_11_10:
542 case TextureFormat::SRGB_DXT1:
543 case TextureFormat::SRGB_DXT3:
544 case TextureFormat::SRGB_DXT5:
545 case TextureFormat::SNORM_DXT1:
546 case TextureFormat::SNORM_DXT3:
547 case TextureFormat::SNORM_DXT5:
548
549 /* #TextureFormat::SFLOAT_32_32_32 Not supported by vendors. */
550 case TextureFormat::SFLOAT_32_32_32:
551
552 case TextureFormat::UINT_8_8_8_8:
553 case TextureFormat::SINT_8_8_8_8:
554 case TextureFormat::UINT_16_16_16_16:
555 case TextureFormat::SINT_16_16_16_16:
556 case TextureFormat::UINT_32_32_32_32:
557 case TextureFormat::SINT_32_32_32_32:
558 case TextureFormat::UINT_8_8:
559 case TextureFormat::SINT_8_8:
560 case TextureFormat::UINT_16_16:
561 case TextureFormat::SINT_16_16:
562 case TextureFormat::UINT_32_32:
563 case TextureFormat::SINT_32_32:
564 case TextureFormat::UINT_8:
565 case TextureFormat::SINT_8:
566 case TextureFormat::UINT_16:
567 case TextureFormat::SINT_16:
568 case TextureFormat::UINT_32:
569 case TextureFormat::SINT_32:
570 case TextureFormat::UNORM_10_10_10_2:
571 case TextureFormat::UINT_10_10_10_2:
572 case TextureFormat::UINT_8_8_8:
573 case TextureFormat::SINT_8_8_8:
574 case TextureFormat::UNORM_8_8_8:
575 case TextureFormat::UINT_16_16_16:
576 case TextureFormat::SINT_16_16_16:
577 case TextureFormat::UNORM_16_16_16:
578 case TextureFormat::UINT_32_32_32:
579 case TextureFormat::SINT_32_32_32:
580 case TextureFormat::SRGBA_8_8_8:
581 case TextureFormat::UFLOAT_9_9_9_EXP_5:
582 case TextureFormat::UNORM_16_DEPTH:
583 return ConversionType::UNSUPPORTED;
584
585 case TextureFormat::Invalid:
586 BLI_assert_unreachable();
587 break;
588 }
589 return ConversionType::UNSUPPORTED;
590}
591
592static ConversionType type_of_conversion_r11g11b10(TextureFormat device_format)
593{
594 if (device_format == TextureFormat::UFLOAT_11_11_10) {
595 return ConversionType::PASS_THROUGH;
596 }
597 return ConversionType::UNSUPPORTED;
598}
599
600static ConversionType type_of_conversion_r10g10b10a2(TextureFormat device_format)
601{
602 if (ELEM(device_format, TextureFormat::UNORM_10_10_10_2, TextureFormat::UINT_10_10_10_2)) {
603 return ConversionType::PASS_THROUGH;
604 }
605 return ConversionType::UNSUPPORTED;
606}
607
608static ConversionType host_to_device(const eGPUDataFormat host_format,
609 const TextureFormat host_texture_format,
610 const TextureFormat device_format)
611{
612 switch (host_format) {
613 case GPU_DATA_FLOAT:
614 return type_of_conversion_float(host_texture_format, device_format);
615 case GPU_DATA_UINT:
616 return type_of_conversion_uint(device_format);
617 case GPU_DATA_INT:
618 return type_of_conversion_int(device_format);
619 case GPU_DATA_HALF_FLOAT:
620 return type_of_conversion_half(device_format);
621 case GPU_DATA_UBYTE:
622 return type_of_conversion_ubyte(device_format);
623 case GPU_DATA_10_11_11_REV:
624 return type_of_conversion_r11g11b10(device_format);
625 case GPU_DATA_2_10_10_10_REV:
626 return type_of_conversion_r10g10b10a2(device_format);
627 case GPU_DATA_UINT_24_8_DEPRECATED:
628 return type_of_conversion_uint248(device_format);
629 }
630
631 return ConversionType::UNSUPPORTED;
632}
633
634static ConversionType reversed(ConversionType type)
635{
636#define CASE_SINGLE(a, b) \
637 case ConversionType::a##_TO_##b: \
638 return ConversionType::b##_TO_##a;
639
640#define CASE_PAIR(a, b) \
641 CASE_SINGLE(a, b) \
642 CASE_SINGLE(b, a)
643
644 switch (type) {
645 case ConversionType::PASS_THROUGH:
646 return ConversionType::PASS_THROUGH;
647 case ConversionType::PASS_THROUGH_D32F_S8:
648 return ConversionType::PASS_THROUGH_D32F_S8;
649
650 CASE_PAIR(FLOAT, UNORM8)
651 CASE_PAIR(FLOAT, SNORM8)
652 CASE_PAIR(FLOAT, UNORM16)
653 CASE_PAIR(FLOAT, SNORM16)
654 CASE_PAIR(FLOAT, UNORM32)
655 CASE_PAIR(UI32, UI16)
656 CASE_PAIR(I32, I16)
657 CASE_PAIR(UI32, UI8)
658 CASE_PAIR(I32, I8)
659 CASE_PAIR(FLOAT, HALF)
660 CASE_PAIR(FLOAT, B10F_G11F_R11F)
661 CASE_PAIR(FLOAT3, HALF4)
662 CASE_PAIR(FLOAT3, FLOAT4)
663 CASE_PAIR(UINT, DEPTH32F_STENCIL8)
664 CASE_PAIR(UI8, HALF)
665
666 case ConversionType::UNSUPPORTED:
667 return ConversionType::UNSUPPORTED;
668 }
669
670#undef CASE_PAIR
671#undef CASE_SINGLE
672
673 return ConversionType::UNSUPPORTED;
674}
675
677
678/* -------------------------------------------------------------------- */
681
682static uint32_t float_to_uint32_t(float value)
683{
684 union {
685 float fl;
686 uint32_t u;
687 } float_to_bits;
688 float_to_bits.fl = value;
689 return float_to_bits.u;
690}
691
692static float uint32_t_to_float(uint32_t value)
693{
694 union {
695 float fl;
696 uint32_t u;
697 } float_to_bits;
698 float_to_bits.u = value;
699 return float_to_bits.fl;
700}
701
702template<typename InnerType> struct ComponentValue {
703 InnerType value;
704};
705template<typename InnerType> struct PixelValue {
706 InnerType value;
707};
708
709using UI8 = ComponentValue<uint8_t>;
710using UI16 = ComponentValue<uint16_t>;
711using UI32 = ComponentValue<uint32_t>;
712using I8 = ComponentValue<int8_t>;
713using I16 = ComponentValue<int16_t>;
714using I32 = ComponentValue<int32_t>;
715using F16 = ComponentValue<uint16_t>;
716using F32 = ComponentValue<float>;
717using FLOAT3 = PixelValue<float3>;
718using FLOAT4 = PixelValue<ColorSceneLinear4f<eAlpha::Premultiplied>>;
719/* NOTE: Vulkan stores R11_G11_B10 in reverse component order. */
720class B10F_G11G_R11F : public PixelValue<uint32_t> {};
721
722class HALF4 : public PixelValue<uint64_t> {
723 public:
724 uint32_t get_r() const
725 {
726 return value & 0xffff;
727 }
728
729 void set_r(uint64_t new_value)
730 {
731 value = (value & 0xffffffffffff0000) | (new_value & 0xffff);
732 }
733 uint64_t get_g() const
734 {
735 return (value >> 16) & 0xffff;
736 }
737
738 void set_g(uint64_t new_value)
739 {
740 value = (value & 0xffffffff0000ffff) | ((new_value & 0xffff) << 16);
741 }
742 uint64_t get_b() const
743 {
744 return (value >> 32) & 0xffff;
745 }
746
747 void set_b(uint64_t new_value)
748 {
749 value = (value & 0xffff0000ffffffff) | ((new_value & 0xffff) << 32);
750 }
751
752 void set_a(uint64_t new_value)
753 {
754 value = (value & 0xffffffffffff) | ((new_value & 0xffff) << 48);
755 }
756};
757
758/* Use a float as we only have the depth aspect in the staging buffers. */
759struct Depth32fStencil8 : ComponentValue<float> {};
760
761template<typename InnerType> struct SignedNormalized {
762 static_assert(std::is_same<InnerType, uint8_t>() || std::is_same<InnerType, uint16_t>());
763 InnerType value;
764
765 static constexpr int32_t scalar()
766 {
767 return (1 << (sizeof(InnerType) * 8 - 1));
768 }
769
770 static constexpr int32_t delta()
771 {
772 return (1 << (sizeof(InnerType) * 8 - 1)) - 1;
773 }
774
775 static constexpr int32_t max()
776 {
777 return ((1 << (sizeof(InnerType) * 8)) - 1);
778 }
779};
780
781template<typename InnerType> struct UnsignedNormalized {
782 static_assert(std::is_same<InnerType, uint8_t>() || std::is_same<InnerType, uint16_t>() ||
783 std::is_same<InnerType, uint32_t>());
784 InnerType value;
785
786 static constexpr size_t used_byte_size()
787 {
788 return sizeof(InnerType);
789 }
790
791 static constexpr uint32_t scalar()
792 {
793 return std::numeric_limits<InnerType>::max();
794 }
795
796 static constexpr uint32_t max()
797 {
798 return std::numeric_limits<InnerType>::max();
799 }
800};
801
802template<typename StorageType> void convert(SignedNormalized<StorageType> &dst, const F32 &src)
803{
804 static constexpr int32_t scalar = SignedNormalized<StorageType>::scalar();
805 static constexpr int32_t delta = SignedNormalized<StorageType>::delta();
806 static constexpr int32_t max = SignedNormalized<StorageType>::max();
807 dst.value = clamp_i((src.value * scalar + delta), 0, max);
808}
809
810template<typename StorageType> void convert(F32 &dst, const SignedNormalized<StorageType> &src)
811{
812 static constexpr int32_t scalar = SignedNormalized<StorageType>::scalar();
813 static constexpr int32_t delta = SignedNormalized<StorageType>::delta();
814 dst.value = float(int32_t(src.value) - delta) / scalar;
815}
816
817template<typename StorageType> void convert(UnsignedNormalized<StorageType> &dst, const F32 &src)
818{
819 static constexpr uint32_t scalar = UnsignedNormalized<StorageType>::scalar();
820 static constexpr uint32_t max = scalar;
821 /* When converting a DEPTH32F to DEPTH24 the scalar gets to large where 1.0 will wrap around and
822 * become 0. Make sure that depth 1.0 will not wrap around. Without this gpu_select_pick will
823 * fail as all depth 1.0 will occlude previous depths. */
824 dst.value = src.value >= 1.0f ? max : max_ff(src.value * float(scalar), 0.0);
825}
826
827template<typename StorageType> void convert(F32 &dst, const UnsignedNormalized<StorageType> &src)
828{
829 static constexpr uint32_t scalar = UnsignedNormalized<StorageType>::scalar();
830 dst.value = float(uint32_t(src.value & scalar)) / float(scalar);
831}
832
833template<typename StorageType>
834void convert(UnsignedNormalized<StorageType> & /*dst*/, const UI32 & /*src*/)
835{
836 BLI_assert_unreachable();
837}
838
839template<typename StorageType> void convert(UI32 &dst, const UnsignedNormalized<StorageType> &src)
840{
841 static constexpr uint32_t scalar = UnsignedNormalized<StorageType>::scalar();
842 dst.value = uint32_t(src.value) & scalar;
843}
844
845/* Copy the contents of src to dst with out performing any actual conversion. */
846template<typename DestinationType, typename SourceType>
847void convert(DestinationType &dst, const SourceType &src)
848{
849 static_assert(std::is_same<DestinationType, UI8>() || std::is_same<DestinationType, UI16>() ||
850 std::is_same<DestinationType, UI32>() || std::is_same<DestinationType, I8>() ||
851 std::is_same<DestinationType, I16>() || std::is_same<DestinationType, I32>());
852 static_assert(std::is_same<SourceType, UI8>() || std::is_same<SourceType, UI16>() ||
853 std::is_same<SourceType, UI32>() || std::is_same<SourceType, I8>() ||
854 std::is_same<SourceType, I16>() || std::is_same<SourceType, I32>());
855 static_assert(!std::is_same<DestinationType, SourceType>());
856 dst.value = src.value;
857}
858
859static void convert(FLOAT3 &dst, const HALF4 &src)
860{
861 dst.value.x = math::half_to_float(src.get_r());
862 dst.value.y = math::half_to_float(src.get_g());
863 dst.value.z = math::half_to_float(src.get_b());
864}
865
866static void convert(HALF4 &dst, const FLOAT3 &src)
867{
868 dst.set_r(math::float_to_half(src.value.x));
869 dst.set_g(math::float_to_half(src.value.y));
870 dst.set_b(math::float_to_half(src.value.z));
871 dst.set_a(0x3c00); /* FP16 1.0 */
872}
873
874static void convert(FLOAT3 &dst, const FLOAT4 &src)
875{
876 dst.value.x = src.value.r;
877 dst.value.y = src.value.g;
878 dst.value.z = src.value.b;
879}
880
881static void convert(FLOAT4 &dst, const FLOAT3 &src)
882{
883 dst.value.r = src.value.x;
884 dst.value.g = src.value.y;
885 dst.value.b = src.value.z;
886 dst.value.a = 1.0f;
887}
888
889static void convert(F16 &dst, const UI8 &src)
890{
891 UnsignedNormalized<uint8_t> un8;
892 un8.value = src.value;
893 F32 f32;
894 convert(f32, un8);
895 dst.value = math::float_to_half(f32.value);
896}
897
898static void convert(UI8 &dst, const F16 &src)
899{
900 F32 f32;
901 f32.value = math::half_to_float(src.value);
902 UnsignedNormalized<uint8_t> un8;
903 convert(un8, f32);
904 dst.value = un8.value;
905}
906
907constexpr uint32_t MASK_10_BITS = 0b1111111111;
908constexpr uint32_t MASK_11_BITS = 0b11111111111;
909constexpr uint8_t SHIFT_B = 22;
910constexpr uint8_t SHIFT_G = 11;
911constexpr uint8_t SHIFT_R = 0;
912
922
930
932
933static void convert(UI32 &dst, const Depth32fStencil8 &src)
934{
935 uint32_t depth = uint32_t(src.value * 0xFFFFFF);
936 dst.value = (depth << 8);
937}
938
939static void convert(Depth32fStencil8 &dst, const UI32 &src)
940{
941 uint32_t depth = (src.value >> 8) & 0xFFFFFF;
942 dst.value = float(depth) * 0xFFFFFF;
943}
944
945template<typename DestinationType, typename SourceType>
946void convert(MutableSpan<DestinationType> dst, Span<SourceType> src)
947{
948 BLI_assert(src.size() == dst.size());
949 for (int64_t index : IndexRange(src.size())) {
950 convert(dst[index], src[index]);
951 }
952}
953
954template<typename DestinationType, typename SourceType>
955void convert_per_component(void *dst_memory,
956 const void *src_memory,
957 size_t buffer_size,
958 TextureFormat device_format)
959{
960 size_t total_components = to_component_len(device_format) * buffer_size;
961 Span<SourceType> src = Span<SourceType>(static_cast<const SourceType *>(src_memory),
962 total_components);
963 MutableSpan<DestinationType> dst = MutableSpan<DestinationType>(
964 static_cast<DestinationType *>(dst_memory), total_components);
965 convert<DestinationType, SourceType>(dst, src);
966}
967
968template<typename DestinationType, typename SourceType>
969void convert_per_pixel(void *dst_memory, const void *src_memory, size_t buffer_size)
970{
971 Span<SourceType> src = Span<SourceType>(static_cast<const SourceType *>(src_memory),
972 buffer_size);
973 MutableSpan<DestinationType> dst = MutableSpan<DestinationType>(
974 static_cast<DestinationType *>(dst_memory), buffer_size);
975 convert<DestinationType, SourceType>(dst, src);
976}
977
978static void convert_buffer(void *dst_memory,
979 const void *src_memory,
980 size_t buffer_size,
981 TextureFormat device_format,
982 ConversionType type)
983{
984 switch (type) {
985 case ConversionType::UNSUPPORTED:
986 return;
987
988 case ConversionType::PASS_THROUGH:
989 memcpy(dst_memory, src_memory, buffer_size * to_bytesize(device_format));
990 return;
991
992 case ConversionType::PASS_THROUGH_D32F_S8:
993 memcpy(dst_memory, src_memory, buffer_size * to_bytesize(TextureFormat::SFLOAT_32_DEPTH));
994 return;
995
996 case ConversionType::UI32_TO_UI16:
997 convert_per_component<UI16, UI32>(dst_memory, src_memory, buffer_size, device_format);
998 break;
999
1000 case ConversionType::UI16_TO_UI32:
1001 convert_per_component<UI32, UI16>(dst_memory, src_memory, buffer_size, device_format);
1002 break;
1003
1004 case ConversionType::UI32_TO_UI8:
1005 convert_per_component<UI8, UI32>(dst_memory, src_memory, buffer_size, device_format);
1006 break;
1007
1008 case ConversionType::UI8_TO_UI32:
1009 convert_per_component<UI32, UI8>(dst_memory, src_memory, buffer_size, device_format);
1010 break;
1011
1012 case ConversionType::I32_TO_I16:
1013 convert_per_component<I16, I32>(dst_memory, src_memory, buffer_size, device_format);
1014 break;
1015
1016 case ConversionType::I16_TO_I32:
1017 convert_per_component<I32, I16>(dst_memory, src_memory, buffer_size, device_format);
1018 break;
1019
1020 case ConversionType::I32_TO_I8:
1021 convert_per_component<I8, I32>(dst_memory, src_memory, buffer_size, device_format);
1022 break;
1023
1024 case ConversionType::I8_TO_I32:
1025 convert_per_component<I32, I8>(dst_memory, src_memory, buffer_size, device_format);
1026 break;
1027
1028 case ConversionType::FLOAT_TO_SNORM8:
1029 convert_per_component<SignedNormalized<uint8_t>, F32>(
1030 dst_memory, src_memory, buffer_size, device_format);
1031 break;
1032 case ConversionType::SNORM8_TO_FLOAT:
1033 convert_per_component<F32, SignedNormalized<uint8_t>>(
1034 dst_memory, src_memory, buffer_size, device_format);
1035 break;
1036
1037 case ConversionType::FLOAT_TO_SNORM16:
1038 convert_per_component<SignedNormalized<uint16_t>, F32>(
1039 dst_memory, src_memory, buffer_size, device_format);
1040 break;
1041 case ConversionType::SNORM16_TO_FLOAT:
1042 convert_per_component<F32, SignedNormalized<uint16_t>>(
1043 dst_memory, src_memory, buffer_size, device_format);
1044 break;
1045
1046 case ConversionType::FLOAT_TO_UNORM8:
1047 convert_per_component<UnsignedNormalized<uint8_t>, F32>(
1048 dst_memory, src_memory, buffer_size, device_format);
1049 break;
1050 case ConversionType::UNORM8_TO_FLOAT:
1051 convert_per_component<F32, UnsignedNormalized<uint8_t>>(
1052 dst_memory, src_memory, buffer_size, device_format);
1053 break;
1054
1055 case ConversionType::FLOAT_TO_UNORM16:
1056 convert_per_component<UnsignedNormalized<uint16_t>, F32>(
1057 dst_memory, src_memory, buffer_size, device_format);
1058 break;
1059 case ConversionType::UNORM16_TO_FLOAT:
1060 convert_per_component<F32, UnsignedNormalized<uint16_t>>(
1061 dst_memory, src_memory, buffer_size, device_format);
1062 break;
1063
1064 case ConversionType::FLOAT_TO_UNORM32:
1065 convert_per_component<UnsignedNormalized<uint32_t>, F32>(
1066 dst_memory, src_memory, buffer_size, device_format);
1067 break;
1068 case ConversionType::UNORM32_TO_FLOAT:
1069 convert_per_component<F32, UnsignedNormalized<uint32_t>>(
1070 dst_memory, src_memory, buffer_size, device_format);
1071 break;
1072
1073 case ConversionType::UI8_TO_HALF:
1074 convert_per_component<F16, UI8>(dst_memory, src_memory, buffer_size, device_format);
1075 break;
1076 case ConversionType::HALF_TO_UI8:
1077 convert_per_component<UI8, F16>(dst_memory, src_memory, buffer_size, device_format);
1078 break;
1079
1080 case ConversionType::FLOAT_TO_HALF: {
1081 size_t element_len = to_component_len(device_format) * buffer_size;
1082 Span<float> src(static_cast<const float *>(src_memory), element_len);
1083 MutableSpan<uint16_t> dst(static_cast<uint16_t *>(dst_memory), element_len);
1084
1085 constexpr int64_t chunk_size = 4 * 1024 * 1024;
1086
1087 threading::parallel_for(IndexRange(element_len), chunk_size, [&](const IndexRange range) {
1088 /* Doing float to half conversion manually to avoid implementation specific behavior
1089 * regarding Inf and NaNs. Use make finite version to avoid unexpected black pixels on
1090 * certain implementation. For platform parity we clamp these infinite values to finite
1091 * values. */
1092 blender::math::float_to_half_make_finite_array(
1093 src.slice(range).data(), dst.slice(range).data(), range.size());
1094 });
1095 break;
1096 }
1097 case ConversionType::HALF_TO_FLOAT:
1098 blender::math::half_to_float_array(static_cast<const uint16_t *>(src_memory),
1099 static_cast<float *>(dst_memory),
1100 to_component_len(device_format) * buffer_size);
1101 break;
1102
1103 case ConversionType::FLOAT_TO_B10F_G11F_R11F:
1104 convert_per_pixel<B10F_G11G_R11F, FLOAT3>(dst_memory, src_memory, buffer_size);
1105 break;
1106
1107 case ConversionType::DEPTH32F_STENCIL8_TO_UINT:
1108 convert_per_pixel<UI32, Depth32fStencil8>(dst_memory, src_memory, buffer_size);
1109 break;
1110 case ConversionType::UINT_TO_DEPTH32F_STENCIL8:
1111 convert_per_pixel<Depth32fStencil8, UI32>(dst_memory, src_memory, buffer_size);
1112 break;
1113
1114 case ConversionType::B10F_G11F_R11F_TO_FLOAT:
1115 convert_per_pixel<FLOAT3, B10F_G11G_R11F>(dst_memory, src_memory, buffer_size);
1116 break;
1117
1118 case ConversionType::FLOAT3_TO_HALF4:
1119 convert_per_pixel<HALF4, FLOAT3>(dst_memory, src_memory, buffer_size);
1120 break;
1121 case ConversionType::HALF4_TO_FLOAT3:
1122 convert_per_pixel<FLOAT3, HALF4>(dst_memory, src_memory, buffer_size);
1123 break;
1124
1125 case ConversionType::FLOAT3_TO_FLOAT4:
1126 convert_per_pixel<FLOAT4, FLOAT3>(dst_memory, src_memory, buffer_size);
1127 break;
1128 case ConversionType::FLOAT4_TO_FLOAT3:
1129 convert_per_pixel<FLOAT3, FLOAT4>(dst_memory, src_memory, buffer_size);
1130 break;
1131 }
1132}
1133
1134/* -------------------------------------------------------------------- */
1137
1138void convert_host_to_device(void *dst_buffer,
1139 const void *src_buffer,
1140 size_t buffer_size,
1141 eGPUDataFormat host_format,
1142 TextureFormat host_texture_format,
1143 TextureFormat device_format)
1144{
1145 ConversionType conversion_type = host_to_device(host_format, host_texture_format, device_format);
1146 BLI_assert(conversion_type != ConversionType::UNSUPPORTED);
1147 convert_buffer(dst_buffer, src_buffer, buffer_size, device_format, conversion_type);
1148}
1149
1150void convert_device_to_host(void *dst_buffer,
1151 const void *src_buffer,
1152 size_t buffer_size,
1153 eGPUDataFormat host_format,
1154 TextureFormat host_texture_format,
1155 TextureFormat device_format)
1156{
1157 ConversionType conversion_type = reversed(
1158 host_to_device(host_format, host_texture_format, device_format));
1159 BLI_assert_msg(conversion_type != ConversionType::UNSUPPORTED,
1160 "Data conversion between host_format and device_format isn't supported (yet).");
1161 convert_buffer(dst_buffer, src_buffer, buffer_size, device_format, conversion_type);
1162}
1163
1165
1166} // namespace blender::gpu
BLI_assert_unreachable
#define BLI_assert_unreachable()
Definition BLI_assert.h:93
BLI_assert
#define BLI_assert(a)
Definition BLI_assert.h:46
BLI_assert_msg
#define BLI_assert_msg(a, msg)
Definition BLI_assert.h:53
BLI_color.hh
max_ff
MINLINE float max_ff(float a, float b)
Definition math_base_inline.cc:324
clamp_i
MINLINE int clamp_i(int value, int min, int max)
Definition math_base_inline.cc:440
BLI_math_half.hh
ELEM
#define ELEM(...)
Definition BLI_utildefines.h:144
eGPUDataFormat
eGPUDataFormat
Definition GPU_texture.hh:657
GPU_DATA_HALF_FLOAT
@ GPU_DATA_HALF_FLOAT
Definition GPU_texture.hh:659
GPU_DATA_INT
@ GPU_DATA_INT
Definition GPU_texture.hh:660
GPU_DATA_10_11_11_REV
@ GPU_DATA_10_11_11_REV
Definition GPU_texture.hh:668
GPU_DATA_UBYTE
@ GPU_DATA_UBYTE
Definition GPU_texture.hh:662
GPU_DATA_UINT
@ GPU_DATA_UINT
Definition GPU_texture.hh:661
GPU_DATA_UINT_24_8_DEPRECATED
@ GPU_DATA_UINT_24_8_DEPRECATED
Definition GPU_texture.hh:666
GPU_DATA_2_10_10_10_REV
@ GPU_DATA_2_10_10_10_REV
Definition GPU_texture.hh:669
GPU_DATA_FLOAT
@ GPU_DATA_FLOAT
Definition GPU_texture.hh:658
int64_t
long long int int64_t
Definition btConvexHullComputer.cpp:31
uint64_t
unsigned long long int uint64_t
Definition btConvexHullComputer.cpp:33
blender::ColorRGBA::r
ChannelStorageType r
Definition BLI_color_types.hh:89
blender::ColorRGBA::g
ChannelStorageType g
Definition BLI_color_types.hh:89
blender::ColorRGBA::b
ChannelStorageType b
Definition BLI_color_types.hh:89
blender::ColorRGBA::a
ChannelStorageType a
Definition BLI_color_types.hh:89
blender::IndexRange::size
constexpr int64_t size() const
Definition BLI_index_range.hh:152
blender::MutableSpan::size
constexpr int64_t size() const
Definition BLI_span.hh:493
blender::MutableSpan::slice
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:573
blender::MutableSpan::data
constexpr T * data() const
Definition BLI_span.hh:539
blender::Span::slice
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:137
blender::Span::data
constexpr const T * data() const
Definition BLI_span.hh:215
blender::Span::size
constexpr int64_t size() const
Definition BLI_span.hh:252
blender::gpu::B10F_G11G_R11F
Definition vk_data_conversion.cc:720
blender::gpu::HALF4::set_g
void set_g(uint64_t new_value)
Definition vk_data_conversion.cc:738
blender::gpu::HALF4::set_r
void set_r(uint64_t new_value)
Definition vk_data_conversion.cc:729
blender::gpu::HALF4::set_a
void set_a(uint64_t new_value)
Definition vk_data_conversion.cc:752
blender::gpu::HALF4::set_b
void set_b(uint64_t new_value)
Definition vk_data_conversion.cc:747
FLOAT
nullptr FLOAT
Definition closures_template.h:123
float
nullptr float
Definition closures_template.h:123
b
b
Definition compositor_morphological_distance_infos.hh:24
HALF
@ HALF
Definition curve_bevel.cc:30
blender::gpu::I16
ComponentValue< int16_t > I16
Definition vk_data_conversion.cc:713
blender::gpu::F16
ComponentValue< uint16_t > F16
Definition vk_data_conversion.cc:715
blender::gpu::UI8
ComponentValue< uint8_t > UI8
Definition vk_data_conversion.cc:709
blender::gpu::MASK_10_BITS
constexpr uint32_t MASK_10_BITS
Definition vk_data_conversion.cc:907
blender::gpu::convert_per_component
void convert_per_component(void *dst_memory, const void *src_memory, size_t buffer_size, TextureFormat device_format)
Definition vk_data_conversion.cc:955
blender::gpu::UI32
ComponentValue< uint32_t > UI32
Definition vk_data_conversion.cc:711
blender::gpu::SHIFT_B
constexpr uint8_t SHIFT_B
Definition vk_data_conversion.cc:909
blender::gpu::reversed
static ConversionType reversed(ConversionType type)
Definition vk_data_conversion.cc:634
blender::gpu::host_to_device
static ConversionType host_to_device(const eGPUDataFormat host_format, const TextureFormat host_texture_format, const TextureFormat device_format)
Definition vk_data_conversion.cc:608
blender::gpu::type_of_conversion_uint
static ConversionType type_of_conversion_uint(TextureFormat device_format)
Definition vk_data_conversion.cc:273
blender::gpu::float_to_uint32_t
static uint32_t float_to_uint32_t(float value)
Definition vk_data_conversion.cc:682
blender::gpu::convert
void convert(SignedNormalized< StorageType > &dst, const F32 &src)
Definition vk_data_conversion.cc:802
blender::gpu::UI16
ComponentValue< uint16_t > UI16
Definition vk_data_conversion.cc:710
blender::gpu::SHIFT_R
constexpr uint8_t SHIFT_R
Definition vk_data_conversion.cc:911
blender::gpu::type_of_conversion_float
static ConversionType type_of_conversion_float(const TextureFormat host_format, const TextureFormat device_format)
Definition vk_data_conversion.cc:79
blender::gpu::SHIFT_G
constexpr uint8_t SHIFT_G
Definition vk_data_conversion.cc:910
blender::gpu::FLOAT3
PixelValue< float3 > FLOAT3
Definition vk_data_conversion.cc:717
blender::gpu::type_of_conversion_uint248
static ConversionType type_of_conversion_uint248(const TextureFormat device_format)
Definition vk_data_conversion.cc:512
blender::gpu::to_bytesize
int to_bytesize(const DataFormat format)
Definition GPU_format.hh:231
blender::gpu::type_of_conversion_ubyte
static ConversionType type_of_conversion_ubyte(TextureFormat device_format)
Definition vk_data_conversion.cc:433
blender::gpu::F32
ComponentValue< float > F32
Definition vk_data_conversion.cc:716
blender::gpu::convert_host_to_device
void convert_host_to_device(void *dst_buffer, const void *src_buffer, size_t buffer_size, eGPUDataFormat host_format, TextureFormat host_texture_format, TextureFormat device_format)
Definition vk_data_conversion.cc:1138
blender::gpu::I32
ComponentValue< int32_t > I32
Definition vk_data_conversion.cc:714
blender::gpu::FLOAT4
PixelValue< ColorSceneLinear4f< eAlpha::Premultiplied > > FLOAT4
Definition vk_data_conversion.cc:718
blender::gpu::I8
ComponentValue< int8_t > I8
Definition vk_data_conversion.cc:712
blender::gpu::type_of_conversion_r10g10b10a2
static ConversionType type_of_conversion_r10g10b10a2(TextureFormat device_format)
Definition vk_data_conversion.cc:600
blender::gpu::convert_buffer
static void convert_buffer(void *dst_memory, const void *src_memory, size_t buffer_size, TextureFormat device_format, ConversionType type)
Definition vk_data_conversion.cc:978
blender::gpu::to_component_len
int to_component_len(TextureFormat format)
Definition gpu_texture_private.hh:524
blender::gpu::type_of_conversion_r11g11b10
static ConversionType type_of_conversion_r11g11b10(TextureFormat device_format)
Definition vk_data_conversion.cc:592
blender::gpu::convert_float_formats
uint32_t convert_float_formats(uint32_t value)
Definition vk_data_conversion.hh:169
blender::gpu::uint32_t_to_float
static float uint32_t_to_float(uint32_t value)
Definition vk_data_conversion.cc:692
blender::gpu::convert_per_pixel
void convert_per_pixel(void *dst_memory, const void *src_memory, size_t buffer_size)
Definition vk_data_conversion.cc:969
blender::gpu::type_of_conversion_half
static ConversionType type_of_conversion_half(TextureFormat device_format)
Definition vk_data_conversion.cc:356
blender::gpu::convert_device_to_host
void convert_device_to_host(void *dst_buffer, const void *src_buffer, size_t buffer_size, eGPUDataFormat host_format, TextureFormat host_texture_format, TextureFormat device_format)
Definition vk_data_conversion.cc:1150
blender::gpu::MASK_11_BITS
constexpr uint32_t MASK_11_BITS
Definition vk_data_conversion.cc:908
blender::gpu::type_of_conversion_int
static ConversionType type_of_conversion_int(TextureFormat device_format)
Definition vk_data_conversion.cc:192
blender::math::float_to_half
uint16_t float_to_half(float v)
Definition math_half.cc:27
blender::math::half_to_float_array
void half_to_float_array(const uint16_t *src, float *dst, size_t length)
Definition math_half.cc:368
blender::math::float_to_half_make_finite_array
void float_to_half_make_finite_array(const float *src, uint16_t *dst, size_t length)
Definition math_half.cc:274
blender::math::half_to_float
float half_to_float(uint16_t v)
Definition math_half.cc:108
blender::threading::parallel_for
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:93
CASE_PAIR
#define CASE_PAIR(value_src, value_dst)
blender::gpu::SignedNormalized::scalar
static constexpr int32_t scalar()
Definition vk_data_conversion.cc:765
blender::gpu::SignedNormalized::delta
static constexpr int32_t delta()
Definition vk_data_conversion.cc:770
blender::gpu::SignedNormalized::max
static constexpr int32_t max()
Definition vk_data_conversion.cc:775
blender::gpu::UnsignedNormalized::max
static constexpr uint32_t max()
Definition vk_data_conversion.cc:796
blender::gpu::UnsignedNormalized::used_byte_size
static constexpr size_t used_byte_size()
Definition vk_data_conversion.cc:786
blender::gpu::UnsignedNormalized::scalar
static constexpr uint32_t scalar()
Definition vk_data_conversion.cc:791
max
max
Definition text_draw.cc:251
vk_data_conversion.hh
Generated on for Blender by  doxygen 1.16.1