dEQP-VK.image.load_store.buffer.r32_sint
dEQP-VK.image.load_store.buffer.r8g8b8a8_unorm
dEQP-VK.image.load_store.buffer.r8g8b8a8_snorm
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_2
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_4
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_8
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_16
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_32
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_64
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_2
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_4
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_8
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_16
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_32
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_64
dEQP-VK.image.format_reinterpret.1d.r32g32b32a32_sfloat_r32g32b32a32_uint
dEQP-VK.image.format_reinterpret.1d.r32g32b32a32_sfloat_r32g32b32a32_sint
dEQP-VK.image.format_reinterpret.1d.r16g16b16a16_sfloat_r16g16b16a16_uint
vktImageSizeTests.hpp
vktImageTexture.cpp
vktImageTexture.hpp
+ vktImageMultisampleLoadStoreTests.cpp
+ vktImageMultisampleLoadStoreTests.hpp
+ vktImageLoadStoreUtil.cpp
+ vktImageLoadStoreUtil.hpp
)
set(DEQP_VK_IMAGE_LIBS
#include "vktImageLoadStoreTests.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktImageTestsUtil.hpp"
+#include "vktImageLoadStoreUtil.hpp"
#include "vktImageTexture.hpp"
#include "vkDefs.hpp"
namespace
{
-typedef de::SharedPtr<Unique<VkDescriptorSet> > SharedVkDescriptorSet;
-typedef de::SharedPtr<Unique<VkImageView> > SharedVkImageView;
-
-template<typename T>
-inline de::SharedPtr<Unique<T> > makeVkSharedPtr (Move<T> vkMove)
-{
- return de::SharedPtr<Unique<T> >(new Unique<T>(vkMove));
-}
-
-inline VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const VkFormat format, const VkImageUsageFlags usage, const VkImageCreateFlags flags)
-{
- const VkImageCreateInfo imageParams =
- {
- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (isCube(texture) ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0u) | flags, // VkImageCreateFlags flags;
- mapImageType(texture.type()), // VkImageType imageType;
- format, // VkFormat format;
- makeExtent3D(texture.layerSize()), // VkExtent3D extent;
- 1u, // deUint32 mipLevels;
- (deUint32)texture.numLayers(), // deUint32 arrayLayers;
- VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
- VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
- usage, // VkImageUsageFlags usage;
- VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
- 0u, // deUint32 queueFamilyIndexCount;
- DE_NULL, // const deUint32* pQueueFamilyIndices;
- VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
- };
- return imageParams;
-}
-
inline VkBufferImageCopy makeBufferImageCopy (const Texture& texture)
{
return image::makeBufferImageCopy(makeExtent3D(texture.layerSize()), texture.numLayers());
}
-ImageType getImageTypeForSingleLayer (const ImageType imageType)
-{
- switch (imageType)
- {
- case IMAGE_TYPE_1D:
- case IMAGE_TYPE_1D_ARRAY:
- return IMAGE_TYPE_1D;
-
- case IMAGE_TYPE_2D:
- case IMAGE_TYPE_2D_ARRAY:
- case IMAGE_TYPE_CUBE:
- case IMAGE_TYPE_CUBE_ARRAY:
- // A single layer for cube is a 2d face
- return IMAGE_TYPE_2D;
-
- case IMAGE_TYPE_3D:
- return IMAGE_TYPE_3D;
-
- case IMAGE_TYPE_BUFFER:
- return IMAGE_TYPE_BUFFER;
-
- default:
- DE_FATAL("Internal test error");
- return IMAGE_TYPE_LAST;
- }
-}
-
-float computeStoreColorScale (const VkFormat format, const tcu::IVec3 imageSize)
-{
- const int maxImageDimension = de::max(imageSize.x(), de::max(imageSize.y(), imageSize.z()));
- const float div = static_cast<float>(maxImageDimension - 1);
-
- if (isUnormFormat(format))
- return 1.0f / div;
- else if (isSnormFormat(format))
- return 2.0f / div;
- else
- return 1.0f;
-}
-
-inline float computeStoreColorBias (const VkFormat format)
-{
- return isSnormFormat(format) ? -1.0f : 0.0f;
-}
-
-inline bool isIntegerFormat (const VkFormat format)
-{
- return isIntFormat(format) || isUintFormat(format);
-}
-
tcu::ConstPixelBufferAccess getLayerOrSlice (const Texture& texture, const tcu::ConstPixelBufferAccess access, const int layer)
{
switch (texture.type())
}
}
-std::string getFormatCaseName (const VkFormat format)
-{
- const std::string fullName = getFormatName(format);
-
- DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
-
- return de::toLower(fullName.substr(10));
-}
-
//! \return true if all layers match in both pixel buffers
bool comparePixelBuffers (tcu::TestLog& log,
const Texture& texture,
}
}
-#if defined(DE_DEBUG)
-inline bool colorScaleAndBiasAreValid (const VkFormat format, const float colorScale, const float colorBias)
-{
- // Only normalized (fixed-point) formats may have scale/bias
- const bool integerOrFloatFormat = isIntFormat(format) || isUintFormat(format) || isFloatFormat(format);
- return !integerOrFloatFormat || (colorScale == 1.0f && colorBias == 0.0f);
-}
-#endif
-
inline bool formatsAreCompatible (const VkFormat format0, const VkFormat format1)
{
return format0 == format1 || mapVkFormat(format0).getPixelSize() == mapVkFormat(format1).getPixelSize();
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©Barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
}
-//! Minimum chunk size is determined by the offset alignment requirements.
-VkDeviceSize getOptimalUniformBufferChunkSize (Context& context, VkDeviceSize minimumRequiredChunkSizeBytes)
-{
- const VkPhysicalDeviceProperties properties = getPhysicalDeviceProperties(context.getInstanceInterface(), context.getPhysicalDevice());
- const VkDeviceSize alignment = properties.limits.minUniformBufferOffsetAlignment;
-
- if (minimumRequiredChunkSizeBytes > alignment)
- return alignment + (minimumRequiredChunkSizeBytes / alignment) * alignment;
- else
- return alignment;
-}
-
class StoreTest : public TestCase
{
public:
src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n"
<< "\n"
<< "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
- << "layout (binding = 0, " << formatQualifierStr << ") writeonly uniform highp " << imageTypeStr << " u_image;\n";
+ << "layout (binding = 0, " << formatQualifierStr << ") writeonly uniform " << imageTypeStr << " u_image;\n";
if (m_singleLayerBind)
src << "layout (binding = 1) readonly uniform Constants {\n"
const VkFormat format,
const bool singleLayerBind)
: StoreTestInstance (context, texture, format, singleLayerBind)
- , m_constantsBufferChunkSizeBytes (getOptimalUniformBufferChunkSize(context, sizeof(deUint32)))
+ , m_constantsBufferChunkSizeBytes (getOptimalUniformBufferChunkSize(context.getInstanceInterface(), context.getPhysicalDevice(), sizeof(deUint32)))
, m_allDescriptorSets (texture.numLayers())
, m_allImageViews (texture.numLayers())
{
src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n"
<< "\n"
<< "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
- << "layout (binding = 0, " << formatQualifierStr << ") " << maybeRestrictStr << "readonly uniform highp " << imageTypeStr << " u_image0;\n"
- << "layout (binding = 1, " << formatQualifierStr << ") " << maybeRestrictStr << "writeonly uniform highp " << imageTypeStr << " u_image1;\n"
+ << "layout (binding = 0, " << formatQualifierStr << ") " << maybeRestrictStr << "readonly uniform " << imageTypeStr << " u_image0;\n"
+ << "layout (binding = 1, " << formatQualifierStr << ") " << maybeRestrictStr << "writeonly uniform " << imageTypeStr << " u_image1;\n"
<< "\n"
<< "void main (void)\n"
<< "{\n"
return new ImageLoadStoreTestInstance(context, m_texture, m_format, m_imageFormat, m_singleLayerBind);
}
-// TODO Which image/format combinations should be supported? Spec says it should be queried with vkGetPhysicalDeviceImageFormatProperties.
-// What about buffer/format? (texel storage buffer) (use vkGetPhysicalDeviceFormatProperties ?)
-
static const Texture s_textures[] =
{
Texture(IMAGE_TYPE_1D, tcu::IVec3(64, 1, 1), 1),
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_formats); ++formatNdx)
{
- groupByImageViewType->addChild(new StoreTest(testCtx, getFormatCaseName(s_formats[formatNdx]), "", texture, s_formats[formatNdx]));
+ groupByImageViewType->addChild(new StoreTest(testCtx, getFormatShortString(s_formats[formatNdx]), "", texture, s_formats[formatNdx]));
if (isLayered)
- groupByImageViewType->addChild(new StoreTest(testCtx, getFormatCaseName(s_formats[formatNdx]) + "_single_layer", "",
+ groupByImageViewType->addChild(new StoreTest(testCtx, getFormatShortString(s_formats[formatNdx]) + "_single_layer", "",
texture, s_formats[formatNdx], StoreTest::FLAG_SINGLE_LAYER_BIND));
}
testGroup->addChild(groupByImageViewType.release());
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_formats); ++formatNdx)
{
- groupByImageViewType->addChild(new LoadStoreTest(testCtx, getFormatCaseName(s_formats[formatNdx]), "",
+ groupByImageViewType->addChild(new LoadStoreTest(testCtx, getFormatShortString(s_formats[formatNdx]), "",
texture, s_formats[formatNdx], s_formats[formatNdx]));
if (isLayered)
- groupByImageViewType->addChild(new LoadStoreTest(testCtx, getFormatCaseName(s_formats[formatNdx]) + "_single_layer", "",
+ groupByImageViewType->addChild(new LoadStoreTest(testCtx, getFormatShortString(s_formats[formatNdx]) + "_single_layer", "",
texture, s_formats[formatNdx], s_formats[formatNdx], LoadStoreTest::FLAG_SINGLE_LAYER_BIND));
}
testGroup->addChild(groupByImageViewType.release());
for (int imageFormatNdx = 0; imageFormatNdx < DE_LENGTH_OF_ARRAY(s_formats); ++imageFormatNdx)
for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(s_formats); ++formatNdx)
{
- //TODO Are all conversions valid or do we have to limit (or expand) somehow? Is it stated anywhere in the spec?
-
- const std::string caseName = getFormatCaseName(s_formats[imageFormatNdx]) + "_" + getFormatCaseName(s_formats[formatNdx]);
+ const std::string caseName = getFormatShortString(s_formats[imageFormatNdx]) + "_" + getFormatShortString(s_formats[formatNdx]);
if (imageFormatNdx != formatNdx && formatsAreCompatible(s_formats[imageFormatNdx], s_formats[formatNdx]))
groupByImageViewType->addChild(new LoadStoreTest(testCtx, caseName, "", texture, s_formats[formatNdx], s_formats[imageFormatNdx]));
}
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2016 The Khronos Group Inc.
+ * Copyright (c) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Image load/store utilities
+ *//*--------------------------------------------------------------------*/
+
+#include "vktImageLoadStoreUtil.hpp"
+#include "vkQueryUtil.hpp"
+
+using namespace vk;
+
+namespace vkt
+{
+namespace image
+{
+
+float computeStoreColorScale (const vk::VkFormat format, const tcu::IVec3 imageSize)
+{
+ const int maxImageDimension = de::max(imageSize.x(), de::max(imageSize.y(), imageSize.z()));
+ const float div = static_cast<float>(maxImageDimension - 1);
+
+ if (isUnormFormat(format))
+ return 1.0f / div;
+ else if (isSnormFormat(format))
+ return 2.0f / div;
+ else
+ return 1.0f;
+}
+
+ImageType getImageTypeForSingleLayer (const ImageType imageType)
+{
+ switch (imageType)
+ {
+ case IMAGE_TYPE_1D:
+ case IMAGE_TYPE_1D_ARRAY:
+ return IMAGE_TYPE_1D;
+
+ case IMAGE_TYPE_2D:
+ case IMAGE_TYPE_2D_ARRAY:
+ case IMAGE_TYPE_CUBE:
+ case IMAGE_TYPE_CUBE_ARRAY:
+ // A single layer for cube is a 2d face
+ return IMAGE_TYPE_2D;
+
+ case IMAGE_TYPE_3D:
+ return IMAGE_TYPE_3D;
+
+ case IMAGE_TYPE_BUFFER:
+ return IMAGE_TYPE_BUFFER;
+
+ default:
+ DE_FATAL("Internal test error");
+ return IMAGE_TYPE_LAST;
+ }
+}
+
+VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const VkFormat format, const VkImageUsageFlags usage, const VkImageCreateFlags flags)
+{
+ const VkSampleCountFlagBits samples = static_cast<VkSampleCountFlagBits>(texture.numSamples()); // integer and bit mask are aligned, so we can cast like this
+
+ const VkImageCreateInfo imageParams =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (isCube(texture) ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0u) | flags, // VkImageCreateFlags flags;
+ mapImageType(texture.type()), // VkImageType imageType;
+ format, // VkFormat format;
+ makeExtent3D(texture.layerSize()), // VkExtent3D extent;
+ 1u, // deUint32 mipLevels;
+ (deUint32)texture.numLayers(), // deUint32 arrayLayers;
+ samples, // VkSampleCountFlagBits samples;
+ VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
+ usage, // VkImageUsageFlags usage;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 0u, // deUint32 queueFamilyIndexCount;
+ DE_NULL, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
+ };
+ return imageParams;
+}
+
+
+//! Minimum chunk size is determined by the offset alignment requirements.
+VkDeviceSize getOptimalUniformBufferChunkSize (const InstanceInterface& vki, const VkPhysicalDevice physDevice, VkDeviceSize minimumRequiredChunkSizeBytes)
+{
+ const VkPhysicalDeviceProperties properties = getPhysicalDeviceProperties(vki, physDevice);
+ const VkDeviceSize alignment = properties.limits.minUniformBufferOffsetAlignment;
+
+ if (minimumRequiredChunkSizeBytes > alignment)
+ return alignment + (minimumRequiredChunkSizeBytes / alignment) * alignment;
+ else
+ return alignment;
+}
+
+} // image
+} // vkt
--- /dev/null
+#ifndef _VKTIMAGELOADSTOREUTIL_HPP
+#define _VKTIMAGELOADSTOREUTIL_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2016 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Image load/store utilities
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "vkDefs.hpp"
+#include "vkImageUtil.hpp"
+#include "vktImageTestsUtil.hpp"
+#include "vktImageTexture.hpp"
+#include "tcuVector.hpp"
+#include "deSharedPtr.hpp"
+
+namespace vkt
+{
+namespace image
+{
+
+typedef de::SharedPtr<vk::Unique<vk::VkDescriptorSet> > SharedVkDescriptorSet;
+typedef de::SharedPtr<vk::Unique<vk::VkImageView> > SharedVkImageView;
+
+template<typename T>
+inline de::SharedPtr<vk::Unique<T> > makeVkSharedPtr (vk::Move<T> vkMove)
+{
+ return de::SharedPtr<vk::Unique<T> >(new vk::Unique<T>(vkMove));
+}
+
+inline float computeStoreColorBias (const vk::VkFormat format)
+{
+ return isSnormFormat(format) ? -1.0f : 0.0f;
+}
+
+inline bool isIntegerFormat (const vk::VkFormat format)
+{
+ return isIntFormat(format) || isUintFormat(format);
+}
+
+inline bool colorScaleAndBiasAreValid (const vk::VkFormat format, const float colorScale, const float colorBias)
+{
+ // Only normalized (fixed-point) formats may have scale/bias
+ const bool integerOrFloatFormat = isIntFormat(format) || isUintFormat(format) || isFloatFormat(format);
+ return !integerOrFloatFormat || (colorScale == 1.0f && colorBias == 0.0f);
+}
+
+float computeStoreColorScale (const vk::VkFormat format, const tcu::IVec3 imageSize);
+ImageType getImageTypeForSingleLayer (const ImageType imageType);
+vk::VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const vk::VkFormat format, const vk::VkImageUsageFlags usage, const vk::VkImageCreateFlags flags);
+vk::VkDeviceSize getOptimalUniformBufferChunkSize (const vk::InstanceInterface& vki, const vk::VkPhysicalDevice physDevice, vk::VkDeviceSize minimumRequiredChunkSizeBytes);
+
+} // image
+} // vkt
+
+#endif // _VKTIMAGELOADSTOREUTIL_HPP
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2016 The Khronos Group Inc.
+ * Copyright (c) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Multisampled image load/store Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktImageMultisampleLoadStoreTests.hpp"
+#include "vktTestCaseUtil.hpp"
+#include "vktImageTestsUtil.hpp"
+#include "vktImageLoadStoreUtil.hpp"
+#include "vktImageTexture.hpp"
+
+#include "vkDefs.hpp"
+#include "vkRef.hpp"
+#include "vkRefUtil.hpp"
+#include "vkPlatform.hpp"
+#include "vkPrograms.hpp"
+#include "vkMemUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkQueryUtil.hpp"
+#include "vkImageUtil.hpp"
+
+#include "deUniquePtr.hpp"
+
+#include "tcuTextureUtil.hpp"
+
+#include <string>
+#include <vector>
+
+namespace vkt
+{
+namespace image
+{
+namespace
+{
+using namespace vk;
+using de::MovePtr;
+using de::UniquePtr;
+using tcu::IVec3;
+
+static const VkFormat CHECKSUM_IMAGE_FORMAT = VK_FORMAT_R32_SINT;
+
+struct CaseDef
+{
+ Texture texture;
+ VkFormat format;
+ VkSampleCountFlagBits numSamples;
+ bool singleLayerBind;
+};
+
+// Multisampled storage image test.
+//
+// Pass 1: Write a slightly different color pattern per-sample to the whole image.
+// Pass 2: Read samples of the same image and check if color values are in the expected range.
+// Write back results as a checksum image and verify them on the host.
+// Each checksum image pixel should contain an integer equal to the number of samples.
+
+void initPrograms (SourceCollections& programCollection, const CaseDef caseDef)
+{
+ const int dimension = (caseDef.singleLayerBind ? caseDef.texture.layerDimension() : caseDef.texture.dimension());
+ const std::string texelCoordStr = (dimension == 1 ? "gx" : dimension == 2 ? "ivec2(gx, gy)" : dimension == 3 ? "ivec3(gx, gy, gz)" : "");
+
+ const ImageType usedImageType = (caseDef.singleLayerBind ? getImageTypeForSingleLayer(caseDef.texture.type()) : caseDef.texture.type());
+ const std::string formatQualifierStr = getShaderImageFormatQualifier(mapVkFormat(caseDef.format));
+ const std::string msImageTypeStr = getShaderImageType(mapVkFormat(caseDef.format), usedImageType, (caseDef.texture.numSamples() > 1));
+
+ const std::string xMax = de::toString(caseDef.texture.size().x() - 1);
+ const std::string yMax = de::toString(caseDef.texture.size().y() - 1);
+ const std::string signednessPrefix = isUintFormat(caseDef.format) ? "u" : isIntFormat(caseDef.format) ? "i" : "";
+ const std::string gvec4Expr = signednessPrefix + "vec4";
+ const int numColorComponents = tcu::getNumUsedChannels(mapVkFormat(caseDef.format).order);
+
+ const float storeColorScale = computeStoreColorScale(caseDef.format, caseDef.texture.size());
+ const float storeColorBias = computeStoreColorBias(caseDef.format);
+ DE_ASSERT(colorScaleAndBiasAreValid(caseDef.format, storeColorScale, storeColorBias));
+
+ const std::string colorScaleExpr = (storeColorScale == 1.0f ? "" : "*" + de::toString(storeColorScale))
+ + (storeColorBias == 0.0f ? "" : " + float(" + de::toString(storeColorBias) + ")");
+ const std::string colorExpr =
+ gvec4Expr + "("
+ + "gx^gy^gz^(sampleNdx >> 5)^(sampleNdx & 31), " // we "split" sampleNdx to keep this value in [0, 31] range for numSamples = 64 case
+ + (numColorComponents > 1 ? "(" + xMax + "-gx)^gy^gz, " : "0, ")
+ + (numColorComponents > 2 ? "gx^(" + yMax + "-gy)^gz, " : "0, ")
+ + (numColorComponents > 3 ? "(" + xMax + "-gx)^(" + yMax + "-gy)^gz" : "1")
+ + ")" + colorScaleExpr;
+
+ // Store shader
+ {
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
+ << "\n"
+ << "layout(local_size_x = 1) in;\n"
+ << "layout(set = 0, binding = 1, " << formatQualifierStr << ") writeonly uniform " << msImageTypeStr << " u_msImage;\n";
+
+ if (caseDef.singleLayerBind)
+ src << "layout(set = 0, binding = 0) readonly uniform Constants {\n"
+ << " int u_layerNdx;\n"
+ << "};\n";
+
+ src << "\n"
+ << "void main (void)\n"
+ << "{\n"
+ << " int gx = int(gl_GlobalInvocationID.x);\n"
+ << " int gy = int(gl_GlobalInvocationID.y);\n"
+ << " int gz = " << (caseDef.singleLayerBind ? "u_layerNdx" : "int(gl_GlobalInvocationID.z)") << ";\n"
+ << "\n"
+ << " for (int sampleNdx = 0; sampleNdx < " << caseDef.texture.numSamples() <<"; ++sampleNdx) {\n"
+ << " imageStore(u_msImage, " << texelCoordStr << ", sampleNdx, " << colorExpr << ");\n"
+ << " }\n"
+ << "}\n";
+
+ programCollection.glslSources.add("comp_store") << glu::ComputeSource(src.str());
+ }
+
+ // Load shader
+ {
+ const tcu::TextureFormat checksumFormat = mapVkFormat(CHECKSUM_IMAGE_FORMAT);
+ const std::string checksumImageTypeStr = getShaderImageType(checksumFormat, usedImageType);
+ const bool useExactCompare = isIntegerFormat(caseDef.format);
+
+ std::ostringstream src;
+ src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
+ << "\n"
+ << "layout(local_size_x = 1) in;\n"
+ << "layout(set = 0, binding = 1, " << formatQualifierStr << ") readonly uniform " << msImageTypeStr << " u_msImage;\n"
+ << "layout(set = 0, binding = 2, " << getShaderImageFormatQualifier(checksumFormat) << ") writeonly uniform " << checksumImageTypeStr << " u_checksumImage;\n";
+
+ if (caseDef.singleLayerBind)
+ src << "layout(set = 0, binding = 0) readonly uniform Constants {\n"
+ << " int u_layerNdx;\n"
+ << "};\n";
+
+ src << "\n"
+ << "void main (void)\n"
+ << "{\n"
+ << " int gx = int(gl_GlobalInvocationID.x);\n"
+ << " int gy = int(gl_GlobalInvocationID.y);\n"
+ << " int gz = " << (caseDef.singleLayerBind ? "u_layerNdx" : "int(gl_GlobalInvocationID.z)") << ";\n"
+ << "\n"
+ << " int checksum = 0;\n"
+ << " for (int sampleNdx = 0; sampleNdx < " << caseDef.texture.numSamples() <<"; ++sampleNdx) {\n"
+ << " " << gvec4Expr << " color = imageLoad(u_msImage, " << texelCoordStr << ", sampleNdx);\n";
+
+ if (useExactCompare)
+ src << " if (color == " << colorExpr << ")\n"
+ << " ++checksum;\n";
+ else
+ src << " " << gvec4Expr << " diff = abs(abs(color) - abs(" << colorExpr << "));\n"
+ << " if (all(lessThan(diff, " << gvec4Expr << "(0.02))))\n"
+ << " ++checksum;\n";
+
+ src << " }\n"
+ << "\n"
+ << " imageStore(u_checksumImage, " << texelCoordStr << ", ivec4(checksum));\n"
+ << "}\n";
+
+ programCollection.glslSources.add("comp_load") << glu::ComputeSource(src.str());
+ }
+}
+
+void checkRequirements (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const CaseDef& caseDef)
+{
+ VkPhysicalDeviceFeatures features;
+ vki.getPhysicalDeviceFeatures(physDevice, &features);
+
+ if (!features.shaderStorageImageMultisample)
+ TCU_THROW(NotSupportedError, "Multisampled storage images are not supported");
+
+ VkImageFormatProperties imageFormatProperties;
+ const VkResult imageFormatResult = vki.getPhysicalDeviceImageFormatProperties(
+ physDevice, caseDef.format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_STORAGE_BIT, (VkImageCreateFlags)0, &imageFormatProperties);
+
+ if (imageFormatResult == VK_ERROR_FORMAT_NOT_SUPPORTED)
+ TCU_THROW(NotSupportedError, "Format is not supported");
+
+ if ((imageFormatProperties.sampleCounts & caseDef.numSamples) != caseDef.numSamples)
+ TCU_THROW(NotSupportedError, "Requested sample count is not supported");
+}
+
+//! Helper function to deal with per-layer resources.
+void insertImageViews (const DeviceInterface& vk, const VkDevice device, const CaseDef& caseDef, const VkFormat format, const VkImage image, std::vector<SharedVkImageView>* const pOutImageViews)
+{
+ if (caseDef.singleLayerBind)
+ {
+ pOutImageViews->clear();
+ pOutImageViews->resize(caseDef.texture.numLayers());
+ for (int layerNdx = 0; layerNdx < caseDef.texture.numLayers(); ++layerNdx)
+ {
+ (*pOutImageViews)[layerNdx] = makeVkSharedPtr(makeImageView(
+ vk, device, image, mapImageViewType(getImageTypeForSingleLayer(caseDef.texture.type())), format,
+ makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, layerNdx, 1u)));
+ }
+ }
+ else // bind all layers at once
+ {
+ pOutImageViews->clear();
+ pOutImageViews->resize(1);
+ (*pOutImageViews)[0] = makeVkSharedPtr(makeImageView(
+ vk, device, image, mapImageViewType(caseDef.texture.type()), format,
+ makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, caseDef.texture.numLayers())));
+ }
+}
+
+//! Helper function to deal with per-layer resources.
+void insertDescriptorSets (const DeviceInterface& vk, const VkDevice device, const CaseDef& caseDef, const VkDescriptorPool descriptorPool, const VkDescriptorSetLayout descriptorSetLayout, std::vector<SharedVkDescriptorSet>* const pOutDescriptorSets)
+{
+ if (caseDef.singleLayerBind)
+ {
+ pOutDescriptorSets->clear();
+ pOutDescriptorSets->resize(caseDef.texture.numLayers());
+ for (int layerNdx = 0; layerNdx < caseDef.texture.numLayers(); ++layerNdx)
+ (*pOutDescriptorSets)[layerNdx] = makeVkSharedPtr(makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout));
+ }
+ else // bind all layers at once
+ {
+ pOutDescriptorSets->clear();
+ pOutDescriptorSets->resize(1);
+ (*pOutDescriptorSets)[0] = makeVkSharedPtr(makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout));
+ }
+}
+
+tcu::TestStatus test (Context& context, const CaseDef caseDef)
+{
+ const InstanceInterface& vki = context.getInstanceInterface();
+ const VkPhysicalDevice physDevice = context.getPhysicalDevice();
+ const DeviceInterface& vk = context.getDeviceInterface();
+ const VkDevice device = context.getDevice();
+ const VkQueue queue = context.getUniversalQueue();
+ const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
+ Allocator& allocator = context.getDefaultAllocator();
+
+ checkRequirements(vki, physDevice, caseDef);
+
+ // Images
+
+ const UniquePtr<Image> msImage(new Image(
+ vk, device, allocator, makeImageCreateInfo(caseDef.texture, caseDef.format, VK_IMAGE_USAGE_STORAGE_BIT, 0u), MemoryRequirement::Any));
+
+ const UniquePtr<Image> checksumImage(new Image(
+ vk, device, allocator,
+ makeImageCreateInfo(Texture(caseDef.texture, 1), CHECKSUM_IMAGE_FORMAT, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0u),
+ MemoryRequirement::Any));
+
+ // Buffer used to pass constants to the shader.
+
+ const int numLayers = caseDef.texture.numLayers();
+ const VkDeviceSize bufferChunkSize = getOptimalUniformBufferChunkSize(vki, physDevice, sizeof(deInt32));
+ const VkDeviceSize constantsBufferSizeBytes = numLayers * bufferChunkSize;
+ UniquePtr<Buffer> constantsBuffer (new Buffer(vk, device, allocator, makeBufferCreateInfo(constantsBufferSizeBytes, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT),
+ MemoryRequirement::HostVisible));
+
+ {
+ const Allocation& alloc = constantsBuffer->getAllocation();
+ deUint8* const basePtr = static_cast<deUint8*>(alloc.getHostPtr());
+
+ deMemset(alloc.getHostPtr(), 0, static_cast<size_t>(constantsBufferSizeBytes));
+
+ for (int layerNdx = 0; layerNdx < numLayers; ++layerNdx)
+ {
+ deInt32* const valuePtr = reinterpret_cast<deInt32*>(basePtr + layerNdx * bufferChunkSize);
+ *valuePtr = layerNdx;
+ }
+
+ flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), constantsBufferSizeBytes);
+ }
+
+ const VkDeviceSize resultBufferSizeBytes = getImageSizeBytes(caseDef.texture.size(), CHECKSUM_IMAGE_FORMAT);
+ UniquePtr<Buffer> resultBuffer (new Buffer(vk, device, allocator, makeBufferCreateInfo(resultBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT),
+ MemoryRequirement::HostVisible));
+
+ {
+ const Allocation& alloc = resultBuffer->getAllocation();
+ deMemset(alloc.getHostPtr(), 0, static_cast<size_t>(resultBufferSizeBytes));
+ flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), resultBufferSizeBytes);
+ }
+
+ // Descriptors
+
+ Unique<VkDescriptorSetLayout> descriptorSetLayout(DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT)
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
+ .build(vk, device));
+
+ Unique<VkDescriptorPool> descriptorPool(DescriptorPoolBuilder()
+ .addType(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, numLayers)
+ .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, numLayers)
+ .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, numLayers)
+ .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, numLayers));
+
+ std::vector<SharedVkDescriptorSet> allDescriptorSets;
+ std::vector<SharedVkImageView> allMultisampledImageViews;
+ std::vector<SharedVkImageView> allChecksumImageViews;
+
+ insertDescriptorSets(vk, device, caseDef, *descriptorPool, *descriptorSetLayout, &allDescriptorSets);
+ insertImageViews (vk, device, caseDef, caseDef.format, **msImage, &allMultisampledImageViews);
+ insertImageViews (vk, device, caseDef, CHECKSUM_IMAGE_FORMAT, **checksumImage, &allChecksumImageViews);
+
+ // Prepare commands
+
+ const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout (vk, device, *descriptorSetLayout));
+ const Unique<VkCommandPool> cmdPool (makeCommandPool (vk, device, queueFamilyIndex));
+ const Unique<VkCommandBuffer> cmdBuffer (makeCommandBuffer (vk, device, *cmdPool));
+
+ const tcu::IVec3 workSize = (caseDef.singleLayerBind ? caseDef.texture.layerSize() : caseDef.texture.size());
+ const int loopNumLayers = (caseDef.singleLayerBind ? numLayers : 1);
+ const VkImageSubresourceRange subresourceAllLayers = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, caseDef.texture.numLayers());
+
+ // Pass 1: Write MS image
+ {
+ const Unique<VkShaderModule> shaderModule (createShaderModule (vk, device, context.getBinaryCollection().get("comp_store"), 0));
+ const Unique<VkPipeline> pipeline (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
+
+ beginCommandBuffer(vk, *cmdBuffer);
+ vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
+
+ {
+ const VkImageMemoryBarrier barriers[] =
+ {
+ makeImageMemoryBarrier((VkAccessFlags)0, VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, **msImage, subresourceAllLayers),
+ makeImageMemoryBarrier((VkAccessFlags)0, VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, **checksumImage, subresourceAllLayers),
+ };
+
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0,
+ 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ }
+
+ for (int layerNdx = 0; layerNdx < loopNumLayers; ++layerNdx)
+ {
+ const VkDescriptorSet descriptorSet = **allDescriptorSets[layerNdx];
+ const VkDescriptorImageInfo descriptorMultiImageInfo = makeDescriptorImageInfo(DE_NULL, **allMultisampledImageViews[layerNdx], VK_IMAGE_LAYOUT_GENERAL);
+ const VkDescriptorBufferInfo descriptorConstantsBufferInfo = makeDescriptorBufferInfo(constantsBuffer->get(), layerNdx*bufferChunkSize, bufferChunkSize);
+
+ DescriptorSetUpdateBuilder()
+ .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descriptorConstantsBufferInfo)
+ .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorMultiImageInfo)
+ .update(vk, device);
+
+ vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
+ vk.cmdDispatch(*cmdBuffer, workSize.x(), workSize.y(), workSize.z());
+ }
+
+ endCommandBuffer(vk, *cmdBuffer);
+ submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+ }
+
+ // Pass 2: "Resolve" MS image in compute shader
+ {
+ const Unique<VkShaderModule> shaderModule (createShaderModule (vk, device, context.getBinaryCollection().get("comp_load"), 0));
+ const Unique<VkPipeline> pipeline (makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
+
+ beginCommandBuffer(vk, *cmdBuffer);
+ vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
+
+ {
+ const VkImageMemoryBarrier barriers[] =
+ {
+ makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, **msImage, subresourceAllLayers),
+ };
+
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0,
+ 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ }
+
+ for (int layerNdx = 0; layerNdx < loopNumLayers; ++layerNdx)
+ {
+ const VkDescriptorSet descriptorSet = **allDescriptorSets[layerNdx];
+ const VkDescriptorImageInfo descriptorMultiImageInfo = makeDescriptorImageInfo(DE_NULL, **allMultisampledImageViews[layerNdx], VK_IMAGE_LAYOUT_GENERAL);
+ const VkDescriptorImageInfo descriptorChecksumImageInfo = makeDescriptorImageInfo(DE_NULL, **allChecksumImageViews[layerNdx], VK_IMAGE_LAYOUT_GENERAL);
+ const VkDescriptorBufferInfo descriptorConstantsBufferInfo = makeDescriptorBufferInfo(constantsBuffer->get(), layerNdx*bufferChunkSize, bufferChunkSize);
+
+ DescriptorSetUpdateBuilder()
+ .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descriptorConstantsBufferInfo)
+ .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorMultiImageInfo)
+ .writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(2u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorChecksumImageInfo)
+ .update(vk, device);
+
+ vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
+ vk.cmdDispatch(*cmdBuffer, workSize.x(), workSize.y(), workSize.z());
+ }
+
+ endCommandBuffer(vk, *cmdBuffer);
+ submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+ }
+
+ // Retrieve result
+ {
+ beginCommandBuffer(vk, *cmdBuffer);
+
+ {
+ const VkImageMemoryBarrier barriers[] =
+ {
+ makeImageMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, **checksumImage, subresourceAllLayers),
+ };
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0,
+ 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ }
+ {
+ const VkBufferImageCopy copyRegion = makeBufferImageCopy(makeExtent3D(caseDef.texture.layerSize()), caseDef.texture.numLayers());
+ vk.cmdCopyImageToBuffer(*cmdBuffer, **checksumImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, **resultBuffer, 1u, ©Region);
+ }
+ {
+ const VkBufferMemoryBarrier barriers[] =
+ {
+ makeBufferMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, **resultBuffer, 0ull, resultBufferSizeBytes),
+ };
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0,
+ 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers, 0u, DE_NULL);
+ }
+
+ endCommandBuffer(vk, *cmdBuffer);
+ submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+ }
+
+ // Verify
+ {
+ const Allocation& alloc = resultBuffer->getAllocation();
+ invalidateMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), resultBufferSizeBytes);
+
+ const IVec3 imageSize = caseDef.texture.size();
+ const deInt32* pDataPtr = static_cast<deInt32*>(alloc.getHostPtr());
+ const deInt32 expectedChecksum = caseDef.texture.numSamples();
+
+ for (int layer = 0; layer < imageSize.z(); ++layer)
+ for (int y = 0; y < imageSize.y(); ++y)
+ for (int x = 0; x < imageSize.x(); ++x)
+ {
+ if (*pDataPtr != expectedChecksum)
+ {
+ context.getTestContext().getLog()
+ << tcu::TestLog::Message << "Some sample colors were incorrect at (x, y, layer) = (" << x << ", " << y << ", " << layer << ")" << tcu::TestLog::EndMessage
+ << tcu::TestLog::Message << "Checksum value is " << *pDataPtr << " but expected " << expectedChecksum << tcu::TestLog::EndMessage;
+
+ return tcu::TestStatus::fail("Some sample colors were incorrect");
+ }
+ ++pDataPtr;
+ }
+
+ return tcu::TestStatus::pass("OK");
+ }
+}
+
+} // anonymous ns
+
+tcu::TestCaseGroup* createImageMultisampleLoadStoreTests (tcu::TestContext& testCtx)
+{
+ const Texture textures[] =
+ {
+ // \note Shader code is tweaked to work with image size of 32, take a look if this needs to be modified.
+ Texture(IMAGE_TYPE_2D, tcu::IVec3(32, 32, 1), 1),
+ Texture(IMAGE_TYPE_2D_ARRAY, tcu::IVec3(32, 32, 1), 4),
+ };
+
+ static const VkFormat formats[] =
+ {
+ VK_FORMAT_R32G32B32A32_SFLOAT,
+ VK_FORMAT_R16G16B16A16_SFLOAT,
+ VK_FORMAT_R32_SFLOAT,
+
+ VK_FORMAT_R32G32B32A32_UINT,
+ VK_FORMAT_R16G16B16A16_UINT,
+ VK_FORMAT_R8G8B8A8_UINT,
+ VK_FORMAT_R32_UINT,
+
+ VK_FORMAT_R32G32B32A32_SINT,
+ VK_FORMAT_R16G16B16A16_SINT,
+ VK_FORMAT_R8G8B8A8_SINT,
+ VK_FORMAT_R32_SINT,
+
+ VK_FORMAT_R8G8B8A8_UNORM,
+
+ VK_FORMAT_R8G8B8A8_SNORM,
+ };
+
+ static const VkSampleCountFlagBits samples[] =
+ {
+ VK_SAMPLE_COUNT_2_BIT,
+ VK_SAMPLE_COUNT_4_BIT,
+ VK_SAMPLE_COUNT_8_BIT,
+ VK_SAMPLE_COUNT_16_BIT,
+ VK_SAMPLE_COUNT_32_BIT,
+ VK_SAMPLE_COUNT_64_BIT,
+ };
+
+ MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "load_store_multisample", "Multisampled image store and load"));
+
+ for (int baseTextureNdx = 0; baseTextureNdx < DE_LENGTH_OF_ARRAY(textures); ++baseTextureNdx)
+ {
+ const Texture& baseTexture = textures[baseTextureNdx];
+ MovePtr<tcu::TestCaseGroup> imageViewGroup (new tcu::TestCaseGroup(testCtx, getImageTypeName(baseTexture.type()).c_str(), ""));
+ const int numLayerBindModes = (baseTexture.numLayers() == 1 ? 1 : 2);
+
+ for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
+ for (int layerBindMode = 0; layerBindMode < numLayerBindModes; ++layerBindMode)
+ {
+ const bool singleLayerBind = (layerBindMode != 0);
+ const std::string formatGroupName = getFormatShortString(formats[formatNdx]) + (singleLayerBind ? "_single_layer" : "");
+ MovePtr<tcu::TestCaseGroup> formatGroup (new tcu::TestCaseGroup(testCtx, formatGroupName.c_str(), ""));
+
+ for (int samplesNdx = 0; samplesNdx < DE_LENGTH_OF_ARRAY(samples); ++samplesNdx)
+ {
+ const std::string samplesCaseName = "samples_" + de::toString(samples[samplesNdx]);
+
+ const CaseDef caseDef =
+ {
+ Texture(baseTexture, samples[samplesNdx]),
+ formats[formatNdx],
+ samples[samplesNdx],
+ singleLayerBind,
+ };
+
+ addFunctionCaseWithPrograms(formatGroup.get(), samplesCaseName, "", initPrograms, test, caseDef);
+ }
+ imageViewGroup->addChild(formatGroup.release());
+ }
+ testGroup->addChild(imageViewGroup.release());
+ }
+
+ return testGroup.release();
+}
+
+} // image
+} // vkt
--- /dev/null
+#ifndef _VKTIMAGEMULTISAMPLELOADSTORETESTS_HPP
+#define _VKTIMAGEMULTISAMPLELOADSTORETESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2016 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Multisampled image load/store Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+namespace image
+{
+
+tcu::TestCaseGroup* createImageMultisampleLoadStoreTests (tcu::TestContext& testCtx);
+
+} // image
+} // vkt
+
+#endif // _VKTIMAGEMULTISAMPLELOADSTORETESTS_HPP
#include "vktImageTests.hpp"
#include "vktImageLoadStoreTests.hpp"
+#include "vktImageMultisampleLoadStoreTests.hpp"
#include "vktImageQualifiersTests.hpp"
#include "vktImageSizeTests.hpp"
#include "vktTestGroupUtil.hpp"
imageTests->addChild(createImageStoreTests(testCtx));
imageTests->addChild(createImageLoadStoreTests(testCtx));
+ imageTests->addChild(createImageMultisampleLoadStoreTests(testCtx));
imageTests->addChild(createImageFormatReinterpretTests(testCtx));
imageTests->addChild(createImageQualifiersTests(testCtx));
imageTests->addChild(createImageSizeTests(testCtx));
}
}
-std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType)
+std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample)
{
std::string formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : "";
std::string imageTypePart;
- switch (imageType)
+ if (multisample)
{
- case IMAGE_TYPE_1D: imageTypePart = "1D"; break;
- case IMAGE_TYPE_1D_ARRAY: imageTypePart = "1DArray"; break;
- case IMAGE_TYPE_2D: imageTypePart = "2D"; break;
- case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DArray"; break;
- case IMAGE_TYPE_3D: imageTypePart = "3D"; break;
- case IMAGE_TYPE_CUBE: imageTypePart = "Cube"; break;
- case IMAGE_TYPE_CUBE_ARRAY: imageTypePart = "CubeArray"; break;
- case IMAGE_TYPE_BUFFER: imageTypePart = "Buffer"; break;
-
- default:
- DE_ASSERT(false);
+ switch (imageType)
+ {
+ case IMAGE_TYPE_2D: imageTypePart = "2DMS"; break;
+ case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DMSArray"; break;
+
+ default:
+ DE_ASSERT(false);
+ }
+ }
+ else
+ {
+ switch (imageType)
+ {
+ case IMAGE_TYPE_1D: imageTypePart = "1D"; break;
+ case IMAGE_TYPE_1D_ARRAY: imageTypePart = "1DArray"; break;
+ case IMAGE_TYPE_2D: imageTypePart = "2D"; break;
+ case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DArray"; break;
+ case IMAGE_TYPE_3D: imageTypePart = "3D"; break;
+ case IMAGE_TYPE_CUBE: imageTypePart = "Cube"; break;
+ case IMAGE_TYPE_CUBE_ARRAY: imageTypePart = "CubeArray"; break;
+ case IMAGE_TYPE_BUFFER: imageTypePart = "Buffer"; break;
+
+ default:
+ DE_ASSERT(false);
+ }
}
return formatPart + "image" + imageTypePart;
return std::string() + orderPart + typePart;
}
+std::string getFormatShortString (const VkFormat format)
+{
+ const std::string fullName = getFormatName(format);
+
+ DE_ASSERT(de::beginsWith(fullName, "VK_FORMAT_"));
+
+ return de::toLower(fullName.substr(10));
+}
+
} // image
} // vkt
vk::VkImageType mapImageType (const ImageType imageType);
vk::VkImageViewType mapImageViewType (const ImageType imageType);
std::string getImageTypeName (const ImageType imageType);
-std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType);
+std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType, const bool multisample = false);
std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format);
class Buffer
return tcu::getPixelSize(vk::mapVkFormat(format)) * imageSize.x() * imageSize.y() * imageSize.z();
}
+std::string getFormatShortString (const vk::VkFormat format);
+
} // image
} // vkt
namespace image
{
-Texture::Texture (const ImageType type_, const tcu::IVec3& layerSize_, const int layers)
- : m_layerSize (layerSize_)
- , m_type (type_)
- , m_numLayers (layers)
+void Texture::checkInvariants (void) const
{
+ DE_ASSERT((m_numSamples == 1) || (m_numSamples == 2) || (m_numSamples == 4) || (m_numSamples == 8) ||
+ (m_numSamples == 16) || (m_numSamples == 32) || (m_numSamples == 64));
DE_ASSERT(m_numLayers >= 1);
DE_ASSERT(m_layerSize.x() >= 1 && m_layerSize.y() >= 1 && m_layerSize.z() >= 1);
- switch (type_)
+ switch (m_type)
{
case IMAGE_TYPE_1D:
case IMAGE_TYPE_BUFFER:
DE_ASSERT(m_numLayers == 1);
+ DE_ASSERT(m_numSamples == 1);
DE_ASSERT(m_layerSize.y() == 1 && m_layerSize.z() == 1);
break;
case IMAGE_TYPE_1D_ARRAY:
+ DE_ASSERT(m_numSamples == 1);
DE_ASSERT(m_layerSize.y() == 1 && m_layerSize.z() == 1);
break;
break;
case IMAGE_TYPE_CUBE:
+ DE_ASSERT(m_numSamples == 1);
DE_ASSERT(m_numLayers == 6);
DE_ASSERT(m_layerSize.z() == 1);
break;
case IMAGE_TYPE_CUBE_ARRAY:
+ DE_ASSERT(m_numSamples == 1);
DE_ASSERT(m_numLayers >= 6 && m_numLayers % 6 == 0);
DE_ASSERT(m_layerSize.z() == 1);
break;
case IMAGE_TYPE_3D:
+ DE_ASSERT(m_numSamples == 1);
DE_ASSERT(m_numLayers == 1);
break;
}
}
+Texture::Texture (const ImageType imageType, const tcu::IVec3& imageLayerSize, const int layers, const int samples)
+ : m_layerSize (imageLayerSize)
+ , m_type (imageType)
+ , m_numLayers (layers)
+ , m_numSamples (samples)
+{
+ checkInvariants();
+}
+
+Texture::Texture (const Texture& other, const int samples)
+ : m_layerSize (other.m_layerSize)
+ , m_type (other.m_type)
+ , m_numLayers (other.m_numLayers)
+ , m_numSamples (samples)
+{
+ checkInvariants();
+}
+
tcu::IVec3 Texture::size (void) const
{
switch (m_type)
class Texture
{
public:
- Texture (const ImageType type, const tcu::IVec3& layerSize, const int layers);
+ Texture (const ImageType imageType, const tcu::IVec3& imageLayerSize, const int layers, const int samples = 1);
+ Texture (const Texture& other, const int samples);
ImageType type (void) const { return m_type; } //!< Texture type
tcu::IVec3 layerSize (void) const { return m_layerSize; } //!< Size of a single layer
int numLayers (void) const { return m_numLayers; } //!< Number of array layers (for array and cube types)
+ int numSamples (void) const { return m_numSamples; } //!< Number of samples per texel (multisampled texture)
tcu::IVec3 size (void) const; //!< Size including number of layers in additional dimension (e.g. z in 2d texture)
int dimension (void) const; //!< Coordinate dimension used for addressing (e.g. 3 (x,y,z) for 2d array)
int layerDimension (void) const; //!< Coordinate dimension used for addressing a single layer (e.g. 2 (x,y) for 2d array)
private:
+ void checkInvariants (void) const;
+
const tcu::IVec3 m_layerSize;
const ImageType m_type;
const int m_numLayers;
+ const int m_numSamples;
};
inline bool isCube (const Texture& texture)
dEQP-VK.image.load_store.buffer.r32_sint
dEQP-VK.image.load_store.buffer.r8g8b8a8_unorm
dEQP-VK.image.load_store.buffer.r8g8b8a8_snorm
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32g32b32a32_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r16g16b16a16_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d.r32_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_2
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_4
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_8
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_16
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_32
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_unorm.samples_64
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_2
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_4
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_8
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_16
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_32
+dEQP-VK.image.load_store_multisample.2d.r8g8b8a8_snorm.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sfloat_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sfloat_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_sfloat_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_uint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_uint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_uint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_uint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32g32b32a32_sint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r16g16b16a16_sint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_sint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r32_sint_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_unorm_single_layer.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm.samples_64
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_2
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_4
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_8
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_16
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_32
+dEQP-VK.image.load_store_multisample.2d_array.r8g8b8a8_snorm_single_layer.samples_64
dEQP-VK.image.format_reinterpret.1d.r32g32b32a32_sfloat_r32g32b32a32_uint
dEQP-VK.image.format_reinterpret.1d.r32g32b32a32_sfloat_r32g32b32a32_sint
dEQP-VK.image.format_reinterpret.1d.r16g16b16a16_sfloat_r16g16b16a16_uint
projects / platform / upstream / VK-GL-CTS.git / commitdiff