Blender V5.3
texture_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "gpu_testing.hh"
6
7#include "MEM_guardedalloc.h"
8
10
11#include "GPU_context.hh"
12#include "GPU_state.hh"
13#include "GPU_texture.hh"
14#include "GPU_texture_pool.hh"
15
17
18/* Not all texture types are supported by all platforms. This define safe guards them until we have
19 * a working workaround or decided to remove support for those texture types. */
20#define RUN_UNSUPPORTED false
21
22/* Skip tests that haven't been developed yet due to non standard data types or it needs an
23 * frame-buffer to create the texture. */
24#define RUN_SRGB_UNIMPLEMENTED false
25#define RUN_NON_STANDARD_UNIMPLEMENTED false
26#define RUN_COMPONENT_UNIMPLEMENTED false
27
28namespace blender::gpu::tests {
29
30static void test_texture_read()
31{
33
36 "rgba32u", 1, 1, 1, TextureFormat::UINT_32_32_32_32, usage, nullptr);
38 "rgba16u", 1, 1, 1, TextureFormat::UINT_16_16_16_16, usage, nullptr);
40 "rgba32f", 1, 1, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
41
42 const float4 fcol = {0.0f, 1.3f, -231.0f, 1000.0f};
43 const uint4 ucol = {0, 1, 2, 12223};
44 GPU_texture_clear(rgba32u, GPU_DATA_UINT, ucol);
45 GPU_texture_clear(rgba16u, GPU_DATA_UINT, ucol);
46 GPU_texture_clear(rgba32f, GPU_DATA_FLOAT, fcol);
47
49
50 uint4 *rgba32u_data = static_cast<uint4 *>(GPU_texture_read(rgba32u, GPU_DATA_UINT, 0));
51 uint4 *rgba16u_data = static_cast<uint4 *>(GPU_texture_read(rgba16u, GPU_DATA_UINT, 0));
52 float4 *rgba32f_data = static_cast<float4 *>(GPU_texture_read(rgba32f, GPU_DATA_FLOAT, 0));
53
54 EXPECT_EQ(ucol, *rgba32u_data);
55 EXPECT_EQ(ucol, *rgba16u_data);
56 EXPECT_EQ(fcol, *rgba32f_data);
57
58 MEM_delete(rgba32u_data);
59 MEM_delete(rgba16u_data);
60 MEM_delete(rgba32f_data);
61
62 GPU_texture_free(rgba32u);
63 GPU_texture_free(rgba16u);
64 GPU_texture_free(rgba32f);
65
67}
68GPU_TEST(texture_read)
69
70static void test_texture_1d()
71{
73 GTEST_SKIP() << "Clearing 1d textures not supported by OpenGL & Metal";
74 }
75 const int SIZE = 32;
77
81 "tex", SIZE, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
82 float4 clear_color(0.9f, 0.7f, 0.2f, 1.0f);
83 GPU_texture_clear(tex, GPU_DATA_FLOAT, clear_color);
84
86
87 float4 *data = static_cast<float4 *>(GPU_texture_read(tex, GPU_DATA_FLOAT, 0));
88 for (int index : IndexRange(SIZE)) {
89 EXPECT_EQ(clear_color, data[index]);
90 }
91 MEM_delete(data);
92
94
96}
97GPU_TEST(texture_1d)
98
100{
102 GTEST_SKIP() << "Clearing 1d textures not supported by OpenGL & Metal";
103 }
104 const int LAYERS = 8;
105 const int SIZE = 32;
107
111 "tex", SIZE, LAYERS, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
112 float4 clear_color(1.0f, 0.5f, 0.2f, 1.0f);
113 GPU_texture_clear(tex, GPU_DATA_FLOAT, clear_color);
114
116
117 float4 *data = static_cast<float4 *>(GPU_texture_read(tex, GPU_DATA_FLOAT, 0));
118 for (int index : IndexRange(SIZE * LAYERS)) {
119 EXPECT_EQ(clear_color, data[index]);
120 }
121 MEM_delete(data);
122
123 GPU_texture_free(tex);
124
126}
127GPU_TEST(texture_1d_array)
128
130{
132 GTEST_SKIP() << "Read back of 1d texture arrays not supported by OpenGL";
133 }
134 const int LAYERS = 8;
135 const int SIZE = 32;
137
138 int total_size = LAYERS * SIZE * 4;
139 float *data_in = MEM_new_array_zeroed<float>(total_size, __func__);
140
143 "tex", SIZE, LAYERS, 1, TextureFormat::SFLOAT_32_32_32_32, usage, data_in);
144
146
147 float *data_out = static_cast<float *>(GPU_texture_read(tex, GPU_DATA_FLOAT, 0));
148 GPU_texture_free(tex);
149
150 EXPECT_EQ(memcmp(data_in, data_out, sizeof(float) * total_size), 0);
151 MEM_delete(data_in);
152 MEM_delete(data_out);
153
155}
156GPU_TEST(texture_1d_array_upload)
157
159{
160 const int LAYERS = 8;
161 const int SIZE = 32;
163
166 "tex", SIZE, SIZE, LAYERS, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
167 float4 clear_color(1.0f, 0.5f, 0.2f, 1.0f);
168 GPU_texture_clear(tex, GPU_DATA_FLOAT, clear_color);
169
171
172 float4 *data = static_cast<float4 *>(GPU_texture_read(tex, GPU_DATA_FLOAT, 0));
173 for (int index : IndexRange(SIZE * SIZE * LAYERS)) {
174 EXPECT_EQ(clear_color, data[index]);
175 }
176 MEM_delete(data);
177
178 GPU_texture_free(tex);
179
181}
182GPU_TEST(texture_2d_array)
183
185{
186 const int LAYERS = 8;
187 const int SIZE = 32;
189
190 int total_size = LAYERS * SIZE * SIZE * 4;
191 float *data_in = MEM_new_array_zeroed<float>(total_size, __func__);
192
195 "tex", SIZE, SIZE, LAYERS, 1, TextureFormat::SFLOAT_32_32_32_32, usage, data_in);
196
198
199 float *data_out = static_cast<float *>(GPU_texture_read(tex, GPU_DATA_FLOAT, 0));
200 GPU_texture_free(tex);
201
202 EXPECT_EQ(memcmp(data_in, data_out, sizeof(float) * total_size), 0);
203 MEM_delete(data_in);
204 MEM_delete(data_out);
205
207}
208GPU_TEST(texture_2d_array_upload)
209
210static void test_texture_cube()
211{
212 const int SIZE = 32;
214
217 "tex", SIZE, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
218 float4 clear_color(1.0f, 0.5f, 0.2f, 1.0f);
219 GPU_texture_clear(tex, GPU_DATA_FLOAT, clear_color);
220
222
223 float4 *data = static_cast<float4 *>(GPU_texture_read(tex, GPU_DATA_FLOAT, 0));
224 for (int index : IndexRange(SIZE * SIZE * 6)) {
225 EXPECT_EQ(clear_color, data[index]);
226 }
227 MEM_delete(data);
228
229 GPU_texture_free(tex);
230
232}
233GPU_TEST(texture_cube)
234
236{
237 const int LAYERS = 2;
238 const int SIZE = 32;
240
243 "tex", SIZE, LAYERS, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
244 float4 clear_color(1.0f, 0.5f, 0.2f, 1.0f);
245 GPU_texture_clear(tex, GPU_DATA_FLOAT, clear_color);
246
247 float4 *data = static_cast<float4 *>(GPU_texture_read(tex, GPU_DATA_FLOAT, 0));
248 for (int index : IndexRange(SIZE * SIZE * 6 * LAYERS)) {
249 EXPECT_EQ(clear_color, data[index]);
250 }
251 MEM_delete(data);
252
253 GPU_texture_free(tex);
254
256}
257GPU_TEST(texture_cube_array)
258
259static void test_texture_3d()
260{
261 const int SIZE = 32;
263
266 "tex", SIZE, SIZE, SIZE, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
267 float4 clear_color(1.0f, 0.5f, 0.2f, 1.0f);
268 GPU_texture_clear(tex, GPU_DATA_FLOAT, clear_color);
269
271
272 float4 *data = static_cast<float4 *>(GPU_texture_read(tex, GPU_DATA_FLOAT, 0));
273 for (int index : IndexRange(SIZE * SIZE * SIZE)) {
274 EXPECT_EQ(clear_color, data[index]);
275 }
276 MEM_delete(data);
277
278 GPU_texture_free(tex);
279
281}
282GPU_TEST(texture_3d)
283
284static void test_texture_copy()
285{
286 const int SIZE = 128;
288
291 "src", SIZE, SIZE, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
293 "dst", SIZE, SIZE, 1, TextureFormat::SFLOAT_32_32_32_32, usage, nullptr);
294
295 const float4 color(0.0, 1.0f, 2.0f, 123.0f);
296 const float4 clear_color(0.0f);
298 GPU_texture_clear(dst_tx, GPU_DATA_FLOAT, clear_color);
299
300 GPU_texture_copy(dst_tx, src_tx);
301
303
304 float4 *data = static_cast<float4 *>(GPU_texture_read(dst_tx, GPU_DATA_FLOAT, 0));
305 for (int index : IndexRange(SIZE * SIZE)) {
307 }
308 MEM_delete(data);
309
310 GPU_texture_free(src_tx);
311 GPU_texture_free(dst_tx);
312
314}
315GPU_TEST(texture_copy)
316
317template<typename DataType> static DataType *generate_test_data(size_t data_len)
318{
320 for (int i : IndexRange(data_len)) {
321 if (std::is_same<DataType, float>()) {
322 data[i] = (DataType)(i % 8) / 8.0f;
323 }
324 else {
325 data[i] = (DataType)(i % 8);
326 }
327 }
328 return data;
329}
330
331template<TextureFormat DeviceFormat, eGPUDataFormat HostFormat, typename DataType, int Size = 16>
333{
334 static_assert(!std::is_same<DataType, float>());
335 static_assert(validate_data_format(DeviceFormat, HostFormat));
338 "texture", Size, Size, 1, DeviceFormat, usage, nullptr);
339 if (texture == nullptr) {
340 GTEST_SKIP() << "Platform doesn't support texture format [" << STRINGIFY(DeviceFormat) << "]";
341 }
342
343 size_t data_len = Size * Size *
344 (HostFormat == GPU_DATA_10_11_11_REV ? to_bytesize(HostFormat) :
345 to_component_len(DeviceFormat));
346
347 DataType *data = static_cast<DataType *>(generate_test_data<DataType>(data_len));
348 GPU_texture_update(texture, HostFormat, data);
349
350 DataType *read_data = static_cast<DataType *>(GPU_texture_read(texture, HostFormat, 0));
351 bool failed = false;
352 for (int i : IndexRange(data_len)) {
353 EXPECT_EQ(data[i], read_data[i]);
354 bool ok = (read_data[i] - data[i]) == 0;
355 failed |= !ok;
356 }
357 EXPECT_FALSE(failed);
358
359 MEM_delete(read_data);
360 MEM_delete(data);
361
363}
364
365template<TextureFormat DeviceFormat, eGPUDataFormat HostFormat, int Size = 16>
366static void texture_create_upload_read_with_bias(float max_allowed_bias)
367{
368 static_assert(validate_data_format(DeviceFormat, HostFormat));
371 "texture", Size, Size, 1, DeviceFormat, usage, nullptr);
372 if (texture == nullptr) {
373 GTEST_SKIP() << "Platform doesn't support texture format [" << STRINGIFY(DeviceFormat) << "]";
374 }
375
376 size_t data_len = Size * Size * to_component_len(DeviceFormat);
377 float *data = static_cast<float *>(generate_test_data<float>(data_len));
378 GPU_texture_update(texture, HostFormat, data);
379
380 float *read_data = static_cast<float *>(GPU_texture_read(texture, HostFormat, 0));
381 float max_used_bias = 0.0f;
382 for (int i : IndexRange(data_len)) {
383 float bias = abs(read_data[i] - data[i]);
384 max_used_bias = max_ff(max_used_bias, bias);
385 }
386 EXPECT_LE(max_used_bias, max_allowed_bias);
387
388 MEM_delete(read_data);
389 MEM_delete(data);
390
392}
393
394/* Derivative of texture_create_upload_read_pixels that doesn't test each component, but a pixel at
395 * a time. This is needed to check the R11G11B10 and similar types. */
396template<TextureFormat DeviceFormat, eGPUDataFormat HostFormat, int Size = 16>
398{
399 using DataType = uint32_t;
400 static_assert(validate_data_format(DeviceFormat, HostFormat));
403 "texture", Size, Size, 1, DeviceFormat, usage, nullptr);
404 ASSERT_NE(texture, nullptr);
405
406 size_t data_len = Size * Size;
407 DataType *data = static_cast<DataType *>(generate_test_data<DataType>(data_len));
408 GPU_texture_update(texture, HostFormat, data);
409
410 DataType *read_data = static_cast<DataType *>(GPU_texture_read(texture, HostFormat, 0));
411 bool failed = false;
412 for (int i : IndexRange(data_len)) {
413 bool ok = (read_data[i] - data[i]) == 0;
414 failed |= !ok;
415 }
416 EXPECT_FALSE(failed);
417
418 MEM_delete(read_data);
419 MEM_delete(data);
420
422}
423
424/* -------------------------------------------------------------------- */
431GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8);
432
437GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA16F);
438
443GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA16);
444
449GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA32F);
450
455GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RG8);
456
461GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RG16F);
462
467GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RG16);
468
473GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RG32F);
474
479GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_R8);
480
485GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_R16F);
486
491GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_R16);
492
497GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_R32F);
498
499#if RUN_NON_STANDARD_UNIMPLEMENTED
500static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB10_A2()
501{
503}
504GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB10_A2);
505
506static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB10_A2UI()
507{
509}
510GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB10_A2UI);
511#endif
512
517GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_R11F_G11F_B10F);
518
523GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8_A8);
524
529GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8_SNORM);
530
535GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA16_SNORM);
536
537#if RUN_UNSUPPORTED
538static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB8()
539{
541}
542GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB8);
543
544static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB8_SNORM()
545{
547}
548GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB8_SNORM);
549
550static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB16F()
551{
553}
554GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB16F);
555
556static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB16()
557{
559}
560GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB16);
561static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB16_SNORM()
562{
564}
565GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB16_SNORM);
566
567static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB32F()
568{
570}
571GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB32F);
572#endif
573
578GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RG8_SNORM);
579
584GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RG16_SNORM);
585
590GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_R8_SNORM);
591
596GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_R16_SNORM);
597
598#if RUN_NON_STANDARD_UNIMPLEMENTED
599static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8_A8_DXT1()
600{
602}
603GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8_A8_DXT1);
604
605static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8_A8_DXT3()
606{
608}
609GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8_A8_DXT3);
610
611static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8_A8_DXT5()
612{
614}
615GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8_A8_DXT5);
616
617static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8_DXT1()
618{
620}
621GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8_DXT1);
622
623static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8_DXT3()
624{
626}
627GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8_DXT3);
628
629static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8_DXT5()
630{
632}
633GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8_DXT5);
634#endif
635
636#if RUN_SRGB_UNIMPLEMENTED
637static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8()
638{
640}
641GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8);
642#endif
643
644#if RUN_NON_STANDARD_UNIMPLEMENTED
645static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB9_E5()
646{
648}
649GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_RGB9_E5);
650#endif
651
656GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_DEPTH_COMPONENT32F);
657
659{
661 GTEST_SKIP() << "Float based texture readback not supported on OpenGL";
662 }
664 GTEST_SKIP()
665 << "Current test uses a range that is outside of [0,1], this is only supported "
666 "when enabling `VK_EXT_depth_range_unrestricted`. We should fix this test case.";
667 }
669 0.0f);
670}
671GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_DEPTH32F_STENCIL8);
672
673#if RUN_COMPONENT_UNIMPLEMENTED
674static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_DEPTH_COMPONENT16()
675{
677}
678GPU_TEST(texture_roundtrip__GPU_DATA_FLOAT__GPU_DEPTH_COMPONENT16);
679#endif
680
682
683/* -------------------------------------------------------------------- */
686
691GPU_TEST(texture_roundtrip__GPU_DATA_HALF_FLOAT__GPU_RGBA16F);
692
697GPU_TEST(texture_roundtrip__GPU_DATA_HALF_FLOAT__GPU_RG16F);
698
703GPU_TEST(texture_roundtrip__GPU_DATA_HALF_FLOAT__GPU_R16F);
704
705#if RUN_UNSUPPORTED
706static void test_texture_roundtrip__GPU_DATA_HALF_FLOAT__GPU_RGB16F()
707{
709}
710GPU_TEST(texture_roundtrip__GPU_DATA_HALF_FLOAT__GPU_RGB16F);
711#endif
712
714
715/* -------------------------------------------------------------------- */
718
723GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RGBA8I);
724
729GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RGBA16I);
730
735GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RGBA32I);
736
741GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RG8I);
742
747GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RG16I);
748
753GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RG32I);
754
759GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_R8I);
760
765GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_R16I);
766
771GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_R32I);
772
773#if RUN_UNSUPPORTED
774static void test_texture_roundtrip__GPU_DATA_INT__GPU_RGB8I()
775{
777}
778GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RGB8I);
779
780static void test_texture_roundtrip__GPU_DATA_INT__GPU_RGB16I()
781{
783}
784GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RGB16I);
785
786static void test_texture_roundtrip__GPU_DATA_INT__GPU_RGB32I()
787{
789}
790GPU_TEST(texture_roundtrip__GPU_DATA_INT__GPU_RGB32I);
791#endif
792
794
795/* -------------------------------------------------------------------- */
798
803GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RGBA8UI);
804
809GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RGBA16UI);
810
815GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RGBA32UI);
816
821GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RG8UI);
822
827GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RG16UI);
828
833GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RG32UI);
834
839GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_R8UI);
840
845GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_R16UI);
846
851GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_R32UI);
852
853#if RUN_UNSUPPORTED
854static void test_texture_roundtrip__GPU_DATA_UINT__GPU_DEPTH32F_STENCIL8()
855{
857}
858GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_DEPTH32F_STENCIL8);
859
860static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RGB8UI()
861{
863}
864GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RGB8UI);
865
866static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RGB16UI()
867{
869}
870GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RGB16UI);
871
872static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RGB32UI()
873{
875}
876GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_RGB32UI);
877
878static void test_texture_roundtrip__GPU_DATA_UINT__GPU_DEPTH_COMPONENT32F()
879{
881}
882GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_DEPTH_COMPONENT32F);
883#endif
884
885#if RUN_COMPONENT_UNIMPLEMENTED
886static void test_texture_roundtrip__GPU_DATA_UINT__GPU_DEPTH_COMPONENT16()
887{
889}
890GPU_TEST(texture_roundtrip__GPU_DATA_UINT__GPU_DEPTH_COMPONENT16);
891#endif
892
894
895/* -------------------------------------------------------------------- */
898
903GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_RGBA8UI);
904
909GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_RGBA8);
910
915GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_RG8UI);
916
921GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_RG8);
922
927GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_R8UI);
928
933GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_R8);
934
939GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_SRGB8_A8);
940
941#if RUN_UNSUPPORTED
942static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_RGB8I()
943{
945}
946GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_RGB8I);
947
948static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_RGB8()
949{
951}
952GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_RGB8);
953
954static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_SRGB8()
955{
957}
958GPU_TEST(texture_roundtrip__GPU_DATA_UBYTE__GPU_SRGB8);
959#endif
960
962
963/* -------------------------------------------------------------------- */
966
967#if RUN_UNSUPPORTED
968static void test_texture_roundtrip__GPU_DATA_UINT_24_8__GPU_DEPTH32F_STENCIL8()
969{
970 texture_create_upload_read<TextureFormat::SFLOAT_32_DEPTH_UINT_8,
972 void>();
973}
974GPU_TEST(texture_roundtrip__GPU_DATA_UINT_24_8__GPU_DEPTH32F_STENCIL8);
975#endif
976
978
979/* -------------------------------------------------------------------- */
982
987GPU_TEST(texture_roundtrip__GPU_DATA_10_11_11_REV__GPU_R11F_G11F_B10F);
988
990
991/* -------------------------------------------------------------------- */
994
999GPU_TEST(texture_roundtrip__GPU_DATA_2_10_10_10_REV__GPU_RGB10_A2);
1000
1008GPU_TEST(texture_roundtrip__GPU_DATA_2_10_10_10_REV__GPU_RGB10_A2UI);
1009
1011
1012/* -------------------------------------------------------------------- */
1015
1017{
1018 const int2 size(1024);
1019 const int2 sub_size(256);
1020 const int2 sub_offset(256);
1021
1023 UNPACK2(size),
1024 2,
1025 TextureFormat::SFLOAT_32_32_32_32,
1027 nullptr);
1028 const float4 clear_color(0.0f, 0.0f, 0.0f, 0.0f);
1030
1031 const float4 texture_color(0.0f, 1.0f, 0.0f, 1.0f);
1032 float4 *texture_data = MEM_new_array_uninitialized<float4>(sub_size.x * sub_size.y, __func__);
1033 for (int i = 0; i < sub_size.x * sub_size.y; i++) {
1034 texture_data[i] = texture_color;
1035 }
1036
1038 texture, GPU_DATA_FLOAT, texture_data, UNPACK2(sub_offset), 0, UNPACK2(sub_size), 1);
1039 float4 *texture_data_read = static_cast<float4 *>(GPU_texture_read(texture, GPU_DATA_FLOAT, 0));
1040
1041 for (int x = 0; x < size.x; x++) {
1042 for (int y = 0; y < sub_offset.y; y++) {
1043 int index = x + y * size.x;
1044 ASSERT_EQ(texture_data_read[index], clear_color);
1045 }
1046 }
1047 for (int y = sub_offset.y; y < sub_offset.y + sub_size.y; y++) {
1048 for (int x = 0; x < sub_offset.x; x++) {
1049 int index = x + y * size.x;
1050 ASSERT_EQ(texture_data_read[index], clear_color);
1051 }
1052 for (int x = sub_offset.x; x < sub_offset.x + sub_size.x; x++) {
1053 int index = x + y * size.x;
1054 ASSERT_EQ(texture_data_read[index], texture_color);
1055 }
1056 for (int x = sub_offset.x + sub_size.x; x < size.x; x++) {
1057 int index = x + y * size.x;
1058 ASSERT_EQ(texture_data_read[index], clear_color);
1059 }
1060 }
1061 for (int x = 0; x < size.x; x++) {
1062 for (int y = sub_offset.y + sub_size.y; y < size.y; y++) {
1063 int index = x + y * size.x;
1064 ASSERT_EQ(texture_data_read[index], clear_color);
1065 }
1066 }
1067
1068 MEM_delete(texture_data);
1069 MEM_delete(texture_data_read);
1071}
1072GPU_TEST(texture_update_sub_no_unpack_row_length);
1073
1075{
1076 const int2 size(1024);
1077 const int2 sub_size(256);
1078 const int2 sub_offset(256);
1079
1081 UNPACK2(size),
1082 2,
1083 TextureFormat::SFLOAT_32_32_32_32,
1085 nullptr);
1086 const float4 clear_color(0.0f, 0.0f, 0.0f, 0.0f);
1088
1089 const float4 texture_color(0.0f, 1.0f, 0.0f, 1.0f);
1090 const float4 texture_color_off(1.0f, 0.0f, 0.0f, 1.0f);
1091 float4 *texture_data = MEM_new_array_uninitialized<float4>(size.x * size.y, __func__);
1092 for (int x = 0; x < size.x; x++) {
1093 for (int y = 0; y < size.y; y++) {
1094 int index = x + y * size.x;
1095 texture_data[index] = ((x >= sub_offset.x && x < sub_offset.x + sub_size.x) &&
1096 (y >= sub_offset.y && y < sub_offset.y + sub_size.y)) ?
1097 texture_color :
1098 texture_color_off;
1099 }
1100 }
1101
1102 float4 *texture_data_offset = &texture_data[sub_offset.x + sub_offset.y * size.x];
1105 texture_data_offset,
1106 UNPACK2(sub_offset),
1107 0,
1108 UNPACK2(sub_size),
1109 1,
1110 size.x);
1111 float4 *texture_data_read = static_cast<float4 *>(GPU_texture_read(texture, GPU_DATA_FLOAT, 0));
1112
1113 for (int x = 0; x < size.x; x++) {
1114 for (int y = 0; y < sub_offset.y; y++) {
1115 int index = x + y * size.x;
1116 ASSERT_EQ(texture_data_read[index], clear_color);
1117 }
1118 }
1119 for (int y = sub_offset.y; y < sub_offset.y + sub_size.y; y++) {
1120 for (int x = 0; x < sub_offset.x; x++) {
1121 int index = x + y * size.x;
1122 ASSERT_EQ(texture_data_read[index], clear_color);
1123 }
1124 for (int x = sub_offset.x; x < sub_offset.x + sub_size.x; x++) {
1125 int index = x + y * size.x;
1126 ASSERT_EQ(texture_data_read[index], texture_color);
1127 }
1128 for (int x = sub_offset.x + sub_size.x; x < size.x; x++) {
1129 int index = x + y * size.x;
1130 ASSERT_EQ(texture_data_read[index], clear_color);
1131 }
1132 }
1133 for (int x = 0; x < size.x; x++) {
1134 for (int y = sub_offset.y + sub_size.y; y < size.y; y++) {
1135 int index = x + y * size.x;
1136 ASSERT_EQ(texture_data_read[index], clear_color);
1137 }
1138 }
1139
1140 MEM_delete(texture_data);
1141 MEM_delete(texture_data_read);
1143}
1144GPU_TEST(texture_update_sub_unpack_row_length);
1145
1147{
1148 const int2 size1(10);
1149 const int2 size2(20);
1150 const int2 size3(30);
1151
1152 TexturePool &pool = TexturePool::get();
1153
1154 TextureFormat format1 = TextureFormat::UNORM_8_8_8_8;
1155 TextureFormat format2 = TextureFormat::SFLOAT_16_16_16_16;
1156 TextureFormat format3 = TextureFormat::SFLOAT_32_32_32_32;
1157
1159
1160 auto test_acquire =
1161 [&](int2 size, TextureFormat format, eGPUTextureUsage usage) -> blender::gpu::Texture * {
1162 gpu::Texture *tex = pool.acquire_texture_2d(size, 1, format, usage);
1163 EXPECT_EQ(GPU_texture_format(tex), format);
1164 EXPECT_EQ(GPU_texture_width(tex), size.x);
1165 EXPECT_EQ(GPU_texture_height(tex), size.y);
1166 return tex;
1167 };
1168
1169 /* Tests multiple acquire. */
1170 gpu::Texture *tex1 = test_acquire(size1, format1, usage);
1171 gpu::Texture *tex2 = test_acquire(size2, format1, usage);
1172 gpu::Texture *tex3 = test_acquire(size3, format2, usage);
1173 gpu::Texture *tex4 = test_acquire(size3, format3, usage);
1174
1175 pool.release_texture(tex1);
1176
1177 /* Tests texture recycling. */
1178 /* Note we don't test if the same texture is reused as this is implementation dependent. */
1179 tex1 = test_acquire(size1, format1, usage);
1180
1181 pool.release_texture(tex1);
1182
1183 /* Tests missing release assert. */
1184 EXPECT_BLI_ASSERT(pool.reset(), "Missing texture release");
1185
1186 pool.release_texture(tex2);
1187 pool.release_texture(tex3);
1188 pool.release_texture(tex4);
1189
1190 /* Expects no assert. */
1191 pool.reset();
1192}
1193GPU_TEST(texture_pool);
1194
1196
1197} // namespace blender::gpu::tests
Read Blender memory allocation and freeing.
#define UNPACK2(a)
#define STRINGIFY(x)
#define ELEM(...)
constexpr IndexRange()=default
virtual void reset(bool force_free=false)=0
virtual void release_texture(Texture *tex)=0
virtual Texture * acquire_texture_2d(int2 extent, int mip_len, TextureFormat format, eGPUTextureUsage usage, const char *name=nullptr)=0
static TexturePool & get()
#define abs
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
#define EXPECT_FALSE(result)
#define EXPECT_LE(result, expect)
#define GPU_TEST(test_name)
static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_R8()
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_R32UI()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_R16I()
static void test_texture_1d()
static void test_texture_1d_array_upload()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_RGBA32I()
static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_RG8UI()
static void test_texture_cube()
static void test_texture_roundtrip__GPU_DATA_HALF_FLOAT__GPU_RGBA16F()
static void test_texture_3d()
static constexpr int Size
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RGBA16UI()
static DataType * generate_test_data(size_t data_len)
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RG8UI()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_RG32I()
static void test_texture_copy()
static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_R8UI()
static void test_texture_2d_array_upload()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA16F()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA32F()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_R32F()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_R8I()
static void texture_create_upload_read_with_bias(float max_allowed_bias)
static void test_texture_roundtrip__GPU_DATA_2_10_10_10_REV__GPU_RGB10_A2UI()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_R16F()
static void test_texture_roundtrip__GPU_DATA_HALF_FLOAT__GPU_R16F()
static void test_texture_update_sub_unpack_row_length()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_R16()
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RGBA32UI()
static void test_texture_roundtrip__GPU_DATA_10_11_11_REV__GPU_R11F_G11F_B10F()
static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_RG8()
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_R8UI()
static void test_texture_1d_array()
static void test_texture_update_sub_no_unpack_row_length()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_R16_SNORM()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_RG16I()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_DEPTH_COMPONENT32F()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RG16_SNORM()
static void test_texture_read()
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_R16UI()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_R11F_G11F_B10F()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8_SNORM()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA16()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_DEPTH32F_STENCIL8()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_RGBA8I()
static void test_texture_2d_array()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RG32F()
static void test_texture_cube_array()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RG16()
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RGBA8UI()
static void texture_create_upload_read_pixel()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_R32I()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_SRGB8_A8()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA8()
static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_RGBA8UI()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_RG8I()
static void texture_create_upload_read()
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RG16UI()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RG16F()
static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_SRGB8_A8()
static void test_texture_roundtrip__GPU_DATA_2_10_10_10_REV__GPU_RGB10_A2()
static void test_texture_pool()
GPU_TEST(compute_indirect)
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_R8()
static void test_texture_roundtrip__GPU_DATA_UBYTE__GPU_RGBA8()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RG8_SNORM()
static void test_texture_roundtrip__GPU_DATA_HALF_FLOAT__GPU_RG16F()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RG8()
static void test_texture_roundtrip__GPU_DATA_INT__GPU_RGBA16I()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_R8_SNORM()
static void test_texture_roundtrip__GPU_DATA_FLOAT__GPU_RGBA16_SNORM()
static void test_texture_roundtrip__GPU_DATA_UINT__GPU_RG32UI()
int to_bytesize(const DataFormat format)
int to_component_len(TextureFormat format)
constexpr bool validate_data_format(TextureFormat tex_format, eGPUDataFormat data_format)
gpu::Texture * GPU_texture_create_cube_array(const char *name, int width, int layer_len, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)
gpu::Texture * GPU_texture_create_1d(const char *name, int width, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)
void GPU_texture_update(gpu::Texture *texture, eGPUDataFormat data_format, const void *data)
gpu::TextureFormat GPU_texture_format(const gpu::Texture *texture)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
GPUBackendType GPU_backend_get_type()
@ GPU_DATA_10_11_11_REV
@ GPU_DATA_UINT_24_8_DEPRECATED
VecBase< uint32_t, 4 > uint4
void GPU_texture_copy(gpu::Texture *dst, gpu::Texture *src)
gpu::Texture * GPU_texture_create_2d_array(const char *name, int width, int height, int layer_len, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)
void GPU_render_begin()
void GPU_texture_update_sub(gpu::Texture *texture, eGPUDataFormat data_format, const void *pixels, int offset_x, int offset_y, int offset_z, int width, int height, int depth, uint unpack_row_length=0)
unsigned int uint32_t
Definition BKE_text.h:81
@ GPU_TEXTURE_USAGE_SHADER_READ
@ GPU_TEXTURE_USAGE_SHADER_WRITE
@ GPU_TEXTURE_USAGE_GENERAL
@ GPU_TEXTURE_USAGE_HOST_READ
@ GPU_TEXTURE_USAGE_ATTACHMENT
void GPU_render_end()
void GPU_memory_barrier(GPUBarrier barrier)
Definition gpu_state.cc:305
BMesh const char void * data
gpu::Texture * GPU_texture_create_3d(const char *name, int width, int height, int depth, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const void *data)
int GPU_texture_width(const gpu::Texture *texture)
@ GPU_BARRIER_TEXTURE_UPDATE
Definition GPU_state.hh:42
gpu::Texture * GPU_texture_create_cube(const char *name, int width, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void GPU_texture_clear(gpu::Texture *texture, eGPUDataFormat data_format, const void *data)
int GPU_texture_height(const gpu::Texture *texture)
MINLINE float max_ff(float a, float b)
void GPU_texture_free(gpu::Texture *texture)
void * GPU_texture_read(gpu::Texture *texture, eGPUDataFormat data_format, int mip_level)
gpu::Texture * GPU_texture_create_2d(const char *name, int width, int height, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)
gpu::Texture * GPU_texture_create_1d_array(const char *name, int width, int layer_len, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1