From 7c89beb93fc6614fe0cc3087e09508349af36357 Mon Sep 17 00:00:00 2001 From: Boris Zanin Date: Mon, 8 Apr 2019 08:34:49 +0200 Subject: [PATCH] Add tests for non strict lines Tests for strict and non-strict lines rasterization: * dEQP-VK.rasterization.*.strict_* * dEQP-VK.rasterization.*.non_strict_* Components: Vulkan VK-GL-CTS issue: 1024 Change-Id: If2c4dbe359be0e2550b063216dbd427f80c980db --- android/cts/master/vk-master-2020-03-01.txt | 80 +++ android/cts/master/vk-master.txt | 80 +++ .../vulkan/rasterization/vktRasterizationTests.cpp | 549 +++++++++++++-------- .../mustpass/master/src/excluded-tests.txt | 7 +- .../mustpass/master/vk-default-no-waivers.txt | 79 ++- external/vulkancts/mustpass/master/vk-default.txt | 79 ++- framework/common/tcuRasterizationVerifier.cpp | 222 ++++++--- framework/common/tcuRasterizationVerifier.hpp | 21 +- 8 files changed, 860 insertions(+), 257 deletions(-) diff --git a/android/cts/master/vk-master-2020-03-01.txt b/android/cts/master/vk-master-2020-03-01.txt index fd13827..9c8fa32 100644 --- a/android/cts/master/vk-master-2020-03-01.txt +++ b/android/cts/master/vk-master-2020-03-01.txt @@ -152502,6 +152502,14 @@ dEQP-VK.sparse_resources.shader_intrinsics.2d_array_sparse_gather.g16_b16_r16_3p dEQP-VK.sparse_resources.shader_intrinsics.2d_array_sparse_gather.g16_b16_r16_3plane_444_unorm.128_128_8 dEQP-VK.sparse_resources.shader_intrinsics.2d_array_sparse_gather.g16_b16_r16_3plane_444_unorm.503_137_3 dEQP-VK.sparse_resources.shader_intrinsics.2d_array_sparse_gather.g16_b16_r16_3plane_444_unorm.11_37_3 +dEQP-VK.rasterization.primitives.no_stipple.strict_lines +dEQP-VK.rasterization.primitives.no_stipple.strict_line_strip +dEQP-VK.rasterization.primitives.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives.no_stipple.strict_line_strip_wide +dEQP-VK.rasterization.primitives.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives.no_stipple.non_strict_line_strip +dEQP-VK.rasterization.primitives.no_stipple.non_strict_lines_wide +dEQP-VK.rasterization.primitives.no_stipple.non_strict_line_strip_wide dEQP-VK.rasterization.primitives.no_stipple.rectangular_lines dEQP-VK.rasterization.primitives.no_stipple.rectangular_line_strip dEQP-VK.rasterization.primitives.no_stipple.rectangular_lines_wide @@ -152554,6 +152562,34 @@ dEQP-VK.rasterization.primitive_size.points.point_size_2048 dEQP-VK.rasterization.primitive_size.points.point_size_4096 dEQP-VK.rasterization.primitive_size.points.point_size_8192 dEQP-VK.rasterization.primitive_size.points.point_size_10000 +dEQP-VK.rasterization.interpolation.basic.strict_lines +dEQP-VK.rasterization.interpolation.basic.strict_line_strip +dEQP-VK.rasterization.interpolation.basic.strict_lines_wide +dEQP-VK.rasterization.interpolation.basic.strict_line_strip_wide +dEQP-VK.rasterization.interpolation.basic.non_strict_lines +dEQP-VK.rasterization.interpolation.basic.non_strict_line_strip +dEQP-VK.rasterization.interpolation.basic.non_strict_lines_wide +dEQP-VK.rasterization.interpolation.basic.non_strict_line_strip_wide +dEQP-VK.rasterization.interpolation.projected.strict_lines +dEQP-VK.rasterization.interpolation.projected.strict_line_strip +dEQP-VK.rasterization.interpolation.projected.strict_lines_wide +dEQP-VK.rasterization.interpolation.projected.strict_line_strip_wide +dEQP-VK.rasterization.interpolation.projected.non_strict_lines +dEQP-VK.rasterization.interpolation.projected.non_strict_line_strip +dEQP-VK.rasterization.interpolation.projected.non_strict_lines_wide +dEQP-VK.rasterization.interpolation.projected.non_strict_line_strip_wide +dEQP-VK.rasterization.flatshading.strict_lines +dEQP-VK.rasterization.flatshading.strict_line_strip +dEQP-VK.rasterization.flatshading.strict_lines_wide +dEQP-VK.rasterization.flatshading.strict_line_strip_wide +dEQP-VK.rasterization.flatshading.non_strict_lines +dEQP-VK.rasterization.flatshading.non_strict_line_strip +dEQP-VK.rasterization.flatshading.non_strict_lines_wide +dEQP-VK.rasterization.flatshading.non_strict_line_strip_wide +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.rectangular_lines dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.rectangular_line_strip dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.rectangular_lines_wide @@ -152598,6 +152634,14 @@ dEQP-VK.rasterization.primitives_multisample_2_bit.dynamic_stipple.smooth_lines dEQP-VK.rasterization.primitives_multisample_2_bit.dynamic_stipple.smooth_line_strip dEQP-VK.rasterization.primitives_multisample_2_bit.dynamic_stipple.smooth_lines_wide dEQP-VK.rasterization.primitives_multisample_2_bit.dynamic_stipple.smooth_line_strip_wide +dEQP-VK.rasterization.interpolation_multisample_2_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_2_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_2_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_2_bit.non_strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.rectangular_lines dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.rectangular_line_strip dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.rectangular_lines_wide @@ -152642,6 +152686,14 @@ dEQP-VK.rasterization.primitives_multisample_4_bit.dynamic_stipple.smooth_lines dEQP-VK.rasterization.primitives_multisample_4_bit.dynamic_stipple.smooth_line_strip dEQP-VK.rasterization.primitives_multisample_4_bit.dynamic_stipple.smooth_lines_wide dEQP-VK.rasterization.primitives_multisample_4_bit.dynamic_stipple.smooth_line_strip_wide +dEQP-VK.rasterization.interpolation_multisample_4_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_4_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_4_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_4_bit.non_strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.rectangular_lines dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.rectangular_line_strip dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.rectangular_lines_wide @@ -152686,6 +152738,14 @@ dEQP-VK.rasterization.primitives_multisample_8_bit.dynamic_stipple.smooth_lines dEQP-VK.rasterization.primitives_multisample_8_bit.dynamic_stipple.smooth_line_strip dEQP-VK.rasterization.primitives_multisample_8_bit.dynamic_stipple.smooth_lines_wide dEQP-VK.rasterization.primitives_multisample_8_bit.dynamic_stipple.smooth_line_strip_wide +dEQP-VK.rasterization.interpolation_multisample_8_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_8_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_8_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_8_bit.non_strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.rectangular_lines dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.rectangular_line_strip dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.rectangular_lines_wide @@ -152730,6 +152790,14 @@ dEQP-VK.rasterization.primitives_multisample_16_bit.dynamic_stipple.smooth_lines dEQP-VK.rasterization.primitives_multisample_16_bit.dynamic_stipple.smooth_line_strip dEQP-VK.rasterization.primitives_multisample_16_bit.dynamic_stipple.smooth_lines_wide dEQP-VK.rasterization.primitives_multisample_16_bit.dynamic_stipple.smooth_line_strip_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_16_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_16_bit.non_strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.rectangular_lines dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.rectangular_line_strip dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.rectangular_lines_wide @@ -152774,6 +152842,14 @@ dEQP-VK.rasterization.primitives_multisample_32_bit.dynamic_stipple.smooth_lines dEQP-VK.rasterization.primitives_multisample_32_bit.dynamic_stipple.smooth_line_strip dEQP-VK.rasterization.primitives_multisample_32_bit.dynamic_stipple.smooth_lines_wide dEQP-VK.rasterization.primitives_multisample_32_bit.dynamic_stipple.smooth_line_strip_wide +dEQP-VK.rasterization.interpolation_multisample_32_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_32_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_32_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_32_bit.non_strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.rectangular_lines dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.rectangular_line_strip dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.rectangular_lines_wide @@ -152818,6 +152894,10 @@ dEQP-VK.rasterization.primitives_multisample_64_bit.dynamic_stipple.smooth_lines dEQP-VK.rasterization.primitives_multisample_64_bit.dynamic_stipple.smooth_line_strip dEQP-VK.rasterization.primitives_multisample_64_bit.dynamic_stipple.smooth_lines_wide dEQP-VK.rasterization.primitives_multisample_64_bit.dynamic_stipple.smooth_line_strip_wide +dEQP-VK.rasterization.interpolation_multisample_64_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_64_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_64_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_64_bit.non_strict_lines_wide dEQP-VK.rasterization.provoking_vertex.triangle_list dEQP-VK.rasterization.provoking_vertex.triangle_list_with_adjacency dEQP-VK.rasterization.provoking_vertex.triangle_strip diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt index 321a139..ddd227b 100644 --- a/android/cts/master/vk-master.txt +++ b/android/cts/master/vk-master.txt @@ -502663,6 +502663,14 @@ dEQP-VK.rasterization.primitives.no_stipple.triangles dEQP-VK.rasterization.primitives.no_stipple.triangle_strip dEQP-VK.rasterization.primitives.no_stipple.triangle_fan dEQP-VK.rasterization.primitives.no_stipple.points +dEQP-VK.rasterization.primitives.no_stipple.strict_lines +dEQP-VK.rasterization.primitives.no_stipple.strict_line_strip +dEQP-VK.rasterization.primitives.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives.no_stipple.strict_line_strip_wide +dEQP-VK.rasterization.primitives.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives.no_stipple.non_strict_line_strip +dEQP-VK.rasterization.primitives.no_stipple.non_strict_lines_wide +dEQP-VK.rasterization.primitives.no_stipple.non_strict_line_strip_wide dEQP-VK.rasterization.primitives.no_stipple.lines dEQP-VK.rasterization.primitives.no_stipple.line_strip dEQP-VK.rasterization.primitives.no_stipple.lines_wide @@ -502785,6 +502793,14 @@ dEQP-VK.rasterization.interpolation.basic.lines dEQP-VK.rasterization.interpolation.basic.line_strip dEQP-VK.rasterization.interpolation.basic.lines_wide dEQP-VK.rasterization.interpolation.basic.line_strip_wide +dEQP-VK.rasterization.interpolation.basic.strict_lines +dEQP-VK.rasterization.interpolation.basic.strict_line_strip +dEQP-VK.rasterization.interpolation.basic.strict_lines_wide +dEQP-VK.rasterization.interpolation.basic.strict_line_strip_wide +dEQP-VK.rasterization.interpolation.basic.non_strict_lines +dEQP-VK.rasterization.interpolation.basic.non_strict_line_strip +dEQP-VK.rasterization.interpolation.basic.non_strict_lines_wide +dEQP-VK.rasterization.interpolation.basic.non_strict_line_strip_wide dEQP-VK.rasterization.interpolation.projected.triangles dEQP-VK.rasterization.interpolation.projected.triangle_strip dEQP-VK.rasterization.interpolation.projected.triangle_fan @@ -502792,6 +502808,14 @@ dEQP-VK.rasterization.interpolation.projected.lines dEQP-VK.rasterization.interpolation.projected.line_strip dEQP-VK.rasterization.interpolation.projected.lines_wide dEQP-VK.rasterization.interpolation.projected.line_strip_wide +dEQP-VK.rasterization.interpolation.projected.strict_lines +dEQP-VK.rasterization.interpolation.projected.strict_line_strip +dEQP-VK.rasterization.interpolation.projected.strict_lines_wide +dEQP-VK.rasterization.interpolation.projected.strict_line_strip_wide +dEQP-VK.rasterization.interpolation.projected.non_strict_lines +dEQP-VK.rasterization.interpolation.projected.non_strict_line_strip +dEQP-VK.rasterization.interpolation.projected.non_strict_lines_wide +dEQP-VK.rasterization.interpolation.projected.non_strict_line_strip_wide dEQP-VK.rasterization.flatshading.triangles dEQP-VK.rasterization.flatshading.triangle_strip dEQP-VK.rasterization.flatshading.triangle_fan @@ -502799,8 +502823,20 @@ dEQP-VK.rasterization.flatshading.lines dEQP-VK.rasterization.flatshading.line_strip dEQP-VK.rasterization.flatshading.lines_wide dEQP-VK.rasterization.flatshading.line_strip_wide +dEQP-VK.rasterization.flatshading.strict_lines +dEQP-VK.rasterization.flatshading.strict_line_strip +dEQP-VK.rasterization.flatshading.strict_lines_wide +dEQP-VK.rasterization.flatshading.strict_line_strip_wide +dEQP-VK.rasterization.flatshading.non_strict_lines +dEQP-VK.rasterization.flatshading.non_strict_line_strip +dEQP-VK.rasterization.flatshading.non_strict_lines_wide +dEQP-VK.rasterization.flatshading.non_strict_line_strip_wide dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.lines_wide @@ -502857,8 +502893,16 @@ dEQP-VK.rasterization.fill_rules_multisample_2_bit.projected dEQP-VK.rasterization.interpolation_multisample_2_bit.triangles dEQP-VK.rasterization.interpolation_multisample_2_bit.lines dEQP-VK.rasterization.interpolation_multisample_2_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_2_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_2_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_2_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_2_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.lines_wide @@ -502915,8 +502959,16 @@ dEQP-VK.rasterization.fill_rules_multisample_4_bit.projected dEQP-VK.rasterization.interpolation_multisample_4_bit.triangles dEQP-VK.rasterization.interpolation_multisample_4_bit.lines dEQP-VK.rasterization.interpolation_multisample_4_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_4_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_4_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_4_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_4_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.lines_wide @@ -502973,8 +503025,16 @@ dEQP-VK.rasterization.fill_rules_multisample_8_bit.projected dEQP-VK.rasterization.interpolation_multisample_8_bit.triangles dEQP-VK.rasterization.interpolation_multisample_8_bit.lines dEQP-VK.rasterization.interpolation_multisample_8_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_8_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_8_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_8_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_8_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.lines_wide @@ -503031,8 +503091,16 @@ dEQP-VK.rasterization.fill_rules_multisample_16_bit.projected dEQP-VK.rasterization.interpolation_multisample_16_bit.triangles dEQP-VK.rasterization.interpolation_multisample_16_bit.lines dEQP-VK.rasterization.interpolation_multisample_16_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_16_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_16_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.lines_wide @@ -503089,8 +503157,16 @@ dEQP-VK.rasterization.fill_rules_multisample_32_bit.projected dEQP-VK.rasterization.interpolation_multisample_32_bit.triangles dEQP-VK.rasterization.interpolation_multisample_32_bit.lines dEQP-VK.rasterization.interpolation_multisample_32_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_32_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_32_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_32_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_32_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.lines_wide @@ -503147,6 +503223,10 @@ dEQP-VK.rasterization.fill_rules_multisample_64_bit.projected dEQP-VK.rasterization.interpolation_multisample_64_bit.triangles dEQP-VK.rasterization.interpolation_multisample_64_bit.lines dEQP-VK.rasterization.interpolation_multisample_64_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_64_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_64_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_64_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_64_bit.non_strict_lines_wide dEQP-VK.rasterization.provoking_vertex.triangle_list dEQP-VK.rasterization.provoking_vertex.triangle_list_with_adjacency dEQP-VK.rasterization.provoking_vertex.triangle_strip diff --git a/external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp b/external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp index 5f35a7d..173dc2b 100644 --- a/external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp +++ b/external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp @@ -118,6 +118,15 @@ enum LineStipple static const deUint32 lineStippleFactor = 2; static const deUint32 lineStipplePattern = 0x0F0F; +enum PrimitiveStrictness +{ + PRIMITIVESTRICTNESS_STRICT = 0, + PRIMITIVESTRICTNESS_NONSTRICT, + PRIMITIVESTRICTNESS_IGNORE, + + PRIMITIVESTRICTNESS_LAST +}; + class BaseRenderingTestCase : public TestCase { public: @@ -174,7 +183,7 @@ protected: const VkPipelineRasterizationStateCreateInfo* getRasterizationStateCreateInfo (void) const; virtual - VkPipelineRasterizationLineStateCreateInfoEXT getLineRasterizationStateCreateInfo (void) const; + VkPipelineRasterizationLineStateCreateInfoEXT* getLineRasterizationStateCreateInfo (void); virtual const VkPipelineColorBlendStateCreateInfo* getColorBlendStateCreateInfo (void) const; @@ -220,6 +229,8 @@ protected: const deUint32 m_additionalRenderSize; const VkDeviceSize m_additionalResultBufferSize; + + VkPipelineRasterizationLineStateCreateInfoEXT m_lineRasterizationStateInfo; }; BaseRenderingTestInstance::BaseRenderingTestInstance (Context& context, VkSampleCountFlagBits sampleCount, deUint32 renderSize, VkFormat imageFormat, deUint32 additionalRenderSize) @@ -242,6 +253,8 @@ BaseRenderingTestInstance::BaseRenderingTestInstance (Context& context, VkSample DescriptorPoolBuilder descriptorPoolBuilder; DescriptorSetLayoutBuilder descriptorSetLayoutBuilder; + deMemset(&m_lineRasterizationStateInfo, 0, sizeof(m_lineRasterizationStateInfo)); + // Command Pool m_commandPool = createCommandPool(vkd, vkDevice, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex); @@ -711,9 +724,7 @@ void BaseRenderingTestInstance::drawPrimitives (tcu::Surface& result, const std: VkPipelineRasterizationStateCreateInfo rasterizationStateInfo = *getRasterizationStateCreateInfo(); - VkPipelineRasterizationLineStateCreateInfoEXT lineRasterizationStateInfo = getLineRasterizationStateCreateInfo(); - - rasterizationStateInfo.pNext = &lineRasterizationStateInfo; + rasterizationStateInfo.pNext = getLineRasterizationStateCreateInfo(); VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo = { @@ -867,9 +878,9 @@ const VkPipelineRasterizationStateCreateInfo* BaseRenderingTestInstance::getRast return &rasterizationStateCreateInfo; } -VkPipelineRasterizationLineStateCreateInfoEXT BaseRenderingTestInstance::getLineRasterizationStateCreateInfo (void) const +VkPipelineRasterizationLineStateCreateInfoEXT* BaseRenderingTestInstance::getLineRasterizationStateCreateInfo (void) { - VkPipelineRasterizationLineStateCreateInfoEXT lineRasterizationStateInfo = + m_lineRasterizationStateInfo = { VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, // VkStructureType sType; DE_NULL, // const void* pNext; @@ -879,7 +890,7 @@ VkPipelineRasterizationLineStateCreateInfoEXT BaseRenderingTestInstance::getLine 0xFFFF, // uint16_t lineStipplePattern; }; - return lineRasterizationStateInfo; + return &m_lineRasterizationStateInfo; } const VkPipelineColorBlendStateCreateInfo* BaseRenderingTestInstance::getColorBlendStateCreateInfo (void) const @@ -993,83 +1004,90 @@ tcu::TestStatus BaseTriangleTestInstance::iterate (void) class BaseLineTestInstance : public BaseRenderingTestInstance { public: - BaseLineTestInstance (Context& context, - VkPrimitiveTopology primitiveTopology, - PrimitiveWideness wideness, - VkSampleCountFlagBits sampleCount, - LineStipple stipple, - VkLineRasterizationModeEXT lineRasterizationMode, - const deUint32 additionalRenderSize = 0); - virtual tcu::TestStatus iterate (void); - virtual float getLineWidth (void) const; - bool getLineStippleEnable (void) const { return m_stipple != LINESTIPPLE_DISABLED; } - virtual bool getLineStippleDynamic (void) const { return m_stipple == LINESTIPPLE_DYNAMIC; }; + BaseLineTestInstance (Context& context, + VkPrimitiveTopology primitiveTopology, + PrimitiveWideness wideness, + PrimitiveStrictness strictness, + VkSampleCountFlagBits sampleCount, + LineStipple stipple, + VkLineRasterizationModeEXT lineRasterizationMode, + const deUint32 additionalRenderSize = 0); + virtual tcu::TestStatus iterate (void); + virtual float getLineWidth (void) const; + bool getLineStippleEnable (void) const { return m_stipple != LINESTIPPLE_DISABLED; } + virtual bool getLineStippleDynamic (void) const { return m_stipple == LINESTIPPLE_DYNAMIC; }; virtual - VkPipelineRasterizationLineStateCreateInfoEXT getLineRasterizationStateCreateInfo (void) const; + VkPipelineRasterizationLineStateCreateInfoEXT* getLineRasterizationStateCreateInfo (void); private: - virtual void generateLines (int iteration, std::vector& outData, std::vector& outLines) = DE_NULL; + virtual void generateLines (int iteration, std::vector& outData, std::vector& outLines) = DE_NULL; - bool resultHasAlpha (tcu::Surface& result); + bool resultHasAlpha (tcu::Surface& result); - int m_iteration; - const int m_iterationCount; - VkPrimitiveTopology m_primitiveTopology; - const PrimitiveWideness m_primitiveWideness; - bool m_allIterationsPassed; - bool m_qualityWarning; - float m_maxLineWidth; - std::vector m_lineWidths; - LineStipple m_stipple; + int m_iteration; + const int m_iterationCount; + VkPrimitiveTopology m_primitiveTopology; + const PrimitiveWideness m_primitiveWideness; + const PrimitiveStrictness m_primitiveStrictness; + bool m_allIterationsPassed; + bool m_qualityWarning; + float m_maxLineWidth; + std::vector m_lineWidths; + LineStipple m_stipple; VkLineRasterizationModeEXT m_lineRasterizationMode; - Move m_additionalImage; - de::MovePtr m_additionalImageMemory; - Move m_additionalImageView; - Move m_additionalResolvedImage; - de::MovePtr m_additionalResolvedImageMemory; - Move m_additionalResolvedImageView; - Move m_additionalFrameBuffer; - Move m_additionalResultBuffer; - de::MovePtr m_additionalResultBufferMemory; + Move m_additionalImage; + de::MovePtr m_additionalImageMemory; + Move m_additionalImageView; + Move m_additionalResolvedImage; + de::MovePtr m_additionalResolvedImageMemory; + Move m_additionalResolvedImageView; + Move m_additionalFrameBuffer; + Move m_additionalResultBuffer; + de::MovePtr m_additionalResultBufferMemory; }; -BaseLineTestInstance::BaseLineTestInstance (Context& context, - VkPrimitiveTopology primitiveTopology, - PrimitiveWideness wideness, - VkSampleCountFlagBits sampleCount, - LineStipple stipple, +BaseLineTestInstance::BaseLineTestInstance (Context& context, + VkPrimitiveTopology primitiveTopology, + PrimitiveWideness wideness, + PrimitiveStrictness strictness, + VkSampleCountFlagBits sampleCount, + LineStipple stipple, VkLineRasterizationModeEXT lineRasterizationMode, const deUint32 additionalRenderSize) - : BaseRenderingTestInstance (context, sampleCount, RESOLUTION_POT, VK_FORMAT_R8G8B8A8_UNORM, additionalRenderSize) - , m_iteration (0) - , m_iterationCount (3) - , m_primitiveTopology (primitiveTopology) - , m_primitiveWideness (wideness) - , m_allIterationsPassed (true) - , m_qualityWarning (false) - , m_maxLineWidth (1.0f) - , m_stipple (stipple) - , m_lineRasterizationMode (lineRasterizationMode) + : BaseRenderingTestInstance (context, sampleCount, RESOLUTION_POT, VK_FORMAT_R8G8B8A8_UNORM, additionalRenderSize) + , m_iteration (0) + , m_iterationCount (3) + , m_primitiveTopology (primitiveTopology) + , m_primitiveWideness (wideness) + , m_primitiveStrictness (strictness) + , m_allIterationsPassed (true) + , m_qualityWarning (false) + , m_maxLineWidth (1.0f) + , m_stipple (stipple) + , m_lineRasterizationMode (lineRasterizationMode) { DE_ASSERT(m_primitiveWideness < PRIMITIVEWIDENESS_LAST); - if (context.isDeviceFunctionalitySupported("VK_EXT_line_rasterization")) + if (m_lineRasterizationMode != VK_LINE_RASTERIZATION_MODE_EXT_LAST) { - VkPhysicalDeviceLineRasterizationPropertiesEXT lineRasterizationProperties = + if (context.isDeviceFunctionalitySupported("VK_EXT_line_rasterization")) { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, // VkStructureType sType; - DE_NULL, // void* pNext; - 0u, // deUint32 lineSubPixelPrecisionBits; - }; + VkPhysicalDeviceLineRasterizationPropertiesEXT lineRasterizationProperties = + { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, // VkStructureType sType; + DE_NULL, // void* pNext; + 0u, // deUint32 lineSubPixelPrecisionBits; + }; - VkPhysicalDeviceProperties2 deviceProperties2; - deviceProperties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; - deviceProperties2.pNext = &lineRasterizationProperties; + VkPhysicalDeviceProperties2 deviceProperties2; + deviceProperties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; + deviceProperties2.pNext = &lineRasterizationProperties; - context.getInstanceInterface().getPhysicalDeviceProperties2(m_context.getPhysicalDevice(), &deviceProperties2); + context.getInstanceInterface().getPhysicalDeviceProperties2(m_context.getPhysicalDevice(), &deviceProperties2); - m_subpixelBits = lineRasterizationProperties.lineSubPixelPrecisionBits; + m_subpixelBits = lineRasterizationProperties.lineSubPixelPrecisionBits; + } } // create line widths @@ -1288,8 +1306,8 @@ tcu::TestStatus BaseLineTestInstance::iterate (void) // compare RasterizationArguments args; LineSceneSpec scene; - - tcu::IVec4 colorBits = tcu::getTextureFormatBitDepth(getTextureFormat()); + tcu::IVec4 colorBits = tcu::getTextureFormatBitDepth(getTextureFormat()); + bool strict = m_primitiveStrictness == PRIMITIVESTRICTNESS_STRICT; args.numSamples = m_multisampling ? 1 : 0; args.subpixelBits = m_subpixelBits; @@ -1337,11 +1355,11 @@ tcu::TestStatus BaseLineTestInstance::iterate (void) } } - if (!verifyRelaxedLineGroupRasterization(resultImage, scene, args, m_context.getTestContext().getLog(), (0 == m_multisampling))) + if (!verifyRelaxedLineGroupRasterization(resultImage, scene, args, m_context.getTestContext().getLog(), (0 == m_multisampling), strict)) { // Retry with weaker verification. If it passes, consider it a quality warning. scene.verificationMode = tcu::VERIFICATIONMODE_WEAKER; - if (!verifyRelaxedLineGroupRasterization(resultImage, scene, args, m_context.getTestContext().getLog())) + if (!verifyRelaxedLineGroupRasterization(resultImage, scene, args, m_context.getTestContext().getLog(), false, strict)) m_allIterationsPassed = false; else m_qualityWarning = true; @@ -1361,14 +1379,21 @@ tcu::TestStatus BaseLineTestInstance::iterate (void) drawPrimitives(additionalResultImage, drawBuffer, colorData, m_primitiveTopology, *m_additionalImage, *m_additionalResolvedImage, *m_additionalFrameBuffer, m_additionalRenderSize, *m_additionalResultBuffer, *m_additionalResultBufferMemory); // Compare - if (!verifyRelaxedLineGroupRasterization(additionalResultImage, scene, args, m_context.getTestContext().getLog(), (0 == m_multisampling))) + if (!verifyRelaxedLineGroupRasterization(additionalResultImage, scene, args, m_context.getTestContext().getLog(), (0 == m_multisampling), strict)) { - // Retry with weaker verification. If it passes, consider it a quality warning. - scene.verificationMode = tcu::VERIFICATIONMODE_WEAKER; - if (!verifyRelaxedLineGroupRasterization(resultImage, scene, args, m_context.getTestContext().getLog(), (0 == m_multisampling))) + if (strict) + { m_allIterationsPassed = false; + } else - m_qualityWarning = true; + { + // Retry with weaker verification. If it passes, consider it a quality warning. + scene.verificationMode = tcu::VERIFICATIONMODE_WEAKER; + if (!verifyRelaxedLineGroupRasterization(resultImage, scene, args, m_context.getTestContext().getLog(), (0 == m_multisampling), strict)) + m_allIterationsPassed = false; + else + m_qualityWarning = true; + } } } } @@ -1396,9 +1421,12 @@ float BaseLineTestInstance::getLineWidth (void) const return m_lineWidths[m_iteration]; } -VkPipelineRasterizationLineStateCreateInfoEXT BaseLineTestInstance::getLineRasterizationStateCreateInfo (void) const +VkPipelineRasterizationLineStateCreateInfoEXT* BaseLineTestInstance::getLineRasterizationStateCreateInfo (void) { - VkPipelineRasterizationLineStateCreateInfoEXT lineRasterizationStateInfo = + if (m_lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_EXT_LAST) + return DE_NULL; + + m_lineRasterizationStateInfo = { VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, // VkStructureType sType; DE_NULL, // const void* pNext; @@ -1410,17 +1438,23 @@ VkPipelineRasterizationLineStateCreateInfoEXT BaseLineTestInstance::getLineRaste if (m_stipple == LINESTIPPLE_STATIC) { - lineRasterizationStateInfo.lineStippleFactor = lineStippleFactor; - lineRasterizationStateInfo.lineStipplePattern = lineStipplePattern; + m_lineRasterizationStateInfo.lineStippleFactor = lineStippleFactor; + m_lineRasterizationStateInfo.lineStipplePattern = lineStipplePattern; } - return lineRasterizationStateInfo; + return &m_lineRasterizationStateInfo; } class PointTestInstance : public BaseRenderingTestInstance { public: - PointTestInstance (Context& context, PrimitiveWideness wideness, VkSampleCountFlagBits sampleCount, /*ignored*/LineStipple stipple, /*ignored*/VkLineRasterizationModeEXT lineRasterizationMode, deUint32 renderSize); + PointTestInstance (Context& context, + PrimitiveWideness wideness, + PrimitiveStrictness strictness, // ignored + VkSampleCountFlagBits sampleCount, + LineStipple stipple, // ignored + VkLineRasterizationModeEXT lineRasterizationMode, // ignored + deUint32 renderSize); // ignored virtual tcu::TestStatus iterate (void); virtual float getPointSize (void) const; @@ -1435,7 +1469,13 @@ private: std::vector m_pointSizes; }; -PointTestInstance::PointTestInstance (Context& context, PrimitiveWideness wideness, VkSampleCountFlagBits sampleCount, /*ignored*/LineStipple stipple, /*ignored*/VkLineRasterizationModeEXT lineRasterizationMode, deUint32) +PointTestInstance::PointTestInstance (Context& context, + PrimitiveWideness wideness, + PrimitiveStrictness strictness, + VkSampleCountFlagBits sampleCount, + LineStipple stipple, + VkLineRasterizationModeEXT lineRasterizationMode, + deUint32 renderSize) : BaseRenderingTestInstance (context, sampleCount) , m_iteration (0) , m_iterationCount (3) @@ -1443,8 +1483,11 @@ PointTestInstance::PointTestInstance (Context& context, PrimitiveWideness widene , m_allIterationsPassed (true) , m_maxPointSize (1.0f) { - (void)stipple; - (void)lineRasterizationMode; + DE_UNREF(strictness); + DE_UNREF(stipple); + DE_UNREF(lineRasterizationMode); + DE_UNREF(renderSize); + // create point sizes if (m_primitiveWideness == PRIMITIVEWIDENESS_NARROW) { @@ -2120,18 +2163,28 @@ template class WidenessTestCase : public BaseRenderingTestCase { public: - WidenessTestCase (tcu::TestContext& context, const std::string& name, const std::string& description, PrimitiveWideness wideness, bool isLineTest, VkSampleCountFlagBits sampleCount, LineStipple stipple, VkLineRasterizationModeEXT lineRasterizationMode, deUint32 additionalRenderSize = 0) - : BaseRenderingTestCase(context, name, description, sampleCount) - , m_wideness (wideness) - , m_isLineTest (isLineTest) - , m_stipple(stipple) - , m_lineRasterizationMode(lineRasterizationMode) + WidenessTestCase (tcu::TestContext& context, + const std::string& name, + const std::string& description, + PrimitiveWideness wideness, + PrimitiveStrictness strictness, + bool isLineTest, + VkSampleCountFlagBits sampleCount, + LineStipple stipple, + VkLineRasterizationModeEXT lineRasterizationMode, + deUint32 additionalRenderSize = 0) + : BaseRenderingTestCase (context, name, description, sampleCount) + , m_wideness(wideness) + , m_strictness (strictness) + , m_isLineTest (isLineTest) + , m_stipple (stipple) + , m_lineRasterizationMode (lineRasterizationMode) , m_additionalRenderSize (additionalRenderSize) {} virtual TestInstance* createInstance (Context& context) const { - return new ConcreteTestInstance(context, m_wideness, m_sampleCount, m_stipple, m_lineRasterizationMode, m_additionalRenderSize); + return new ConcreteTestInstance(context, m_wideness, m_strictness, m_sampleCount, m_stipple, m_lineRasterizationMode, m_additionalRenderSize); } virtual void checkSupport (Context& context) const @@ -2143,40 +2196,65 @@ public: switch (m_lineRasterizationMode) { - default: - DE_ASSERT(0); // fallthrough - case VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT: - if (!context.getDeviceProperties().limits.strictLines) - TCU_THROW(NotSupportedError, "Strict rasterization is not supported"); - - if (getLineStippleEnable() && - !context.getLineRasterizationFeaturesEXT().stippledRectangularLines) - TCU_THROW(NotSupportedError, "Stippled rectangular lines not supported"); - break; - case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT: - if (!context.getLineRasterizationFeaturesEXT().rectangularLines) - TCU_THROW(NotSupportedError, "Rectangular lines not supported"); - - if (getLineStippleEnable() && - !context.getLineRasterizationFeaturesEXT().stippledRectangularLines) - TCU_THROW(NotSupportedError, "Stippled rectangular lines not supported"); - break; - case VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT: - if (!context.getLineRasterizationFeaturesEXT().bresenhamLines) - TCU_THROW(NotSupportedError, "Bresenham lines not supported"); - - if (getLineStippleEnable() && - !context.getLineRasterizationFeaturesEXT().stippledBresenhamLines) - TCU_THROW(NotSupportedError, "Stippled Bresenham lines not supported"); - break; - case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT: - if (!context.getLineRasterizationFeaturesEXT().smoothLines) - TCU_THROW(NotSupportedError, "Smooth lines not supported"); - - if (getLineStippleEnable() && - !context.getLineRasterizationFeaturesEXT().stippledSmoothLines) - TCU_THROW(NotSupportedError, "Stippled smooth lines not supported"); - break; + default: + TCU_THROW(InternalError, "Unknown line rasterization mode"); + + case VK_LINE_RASTERIZATION_MODE_EXT_LAST: + { + if (m_strictness == PRIMITIVESTRICTNESS_STRICT) + if (!context.getDeviceProperties().limits.strictLines) + TCU_THROW(NotSupportedError, "Strict rasterization is not supported"); + + if (m_strictness == PRIMITIVESTRICTNESS_NONSTRICT) + if (context.getDeviceProperties().limits.strictLines) + TCU_THROW(NotSupportedError, "Nonstrict rasterization is not supported"); + + break; + } + + case VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT: + { + if (!context.getDeviceProperties().limits.strictLines) + TCU_THROW(NotSupportedError, "Strict rasterization is not supported"); + + if (getLineStippleEnable() && + !context.getLineRasterizationFeaturesEXT().stippledRectangularLines) + TCU_THROW(NotSupportedError, "Stippled rectangular lines not supported"); + break; + } + + case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT: + { + if (!context.getLineRasterizationFeaturesEXT().rectangularLines) + TCU_THROW(NotSupportedError, "Rectangular lines not supported"); + + if (getLineStippleEnable() && + !context.getLineRasterizationFeaturesEXT().stippledRectangularLines) + TCU_THROW(NotSupportedError, "Stippled rectangular lines not supported"); + break; + } + + case VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT: + { + if (!context.getLineRasterizationFeaturesEXT().bresenhamLines) + TCU_THROW(NotSupportedError, "Bresenham lines not supported"); + + if (getLineStippleEnable() && + !context.getLineRasterizationFeaturesEXT().stippledBresenhamLines) + TCU_THROW(NotSupportedError, "Stippled Bresenham lines not supported"); + break; + } + + case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT: + { + if (!context.getLineRasterizationFeaturesEXT().smoothLines) + TCU_THROW(NotSupportedError, "Smooth lines not supported"); + + if (getLineStippleEnable() && + !context.getLineRasterizationFeaturesEXT().stippledSmoothLines) + TCU_THROW(NotSupportedError, "Stippled smooth lines not supported"); + break; + } } } else @@ -2190,18 +2268,19 @@ public: virtual bool getLineStippleDynamic (void) const { return m_stipple == LINESTIPPLE_DYNAMIC; }; protected: - const PrimitiveWideness m_wideness; - const bool m_isLineTest; + const PrimitiveWideness m_wideness; + const PrimitiveStrictness m_strictness; + const bool m_isLineTest; const LineStipple m_stipple; const VkLineRasterizationModeEXT m_lineRasterizationMode; - const deUint32 m_additionalRenderSize; + const deUint32 m_additionalRenderSize; }; class LinesTestInstance : public BaseLineTestInstance { public: - LinesTestInstance (Context& context, PrimitiveWideness wideness, VkSampleCountFlagBits sampleCount, LineStipple stipple, VkLineRasterizationModeEXT lineRasterizationMode, deUint32 additionalRenderSize = 0) - : BaseLineTestInstance(context, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, wideness, sampleCount, stipple, lineRasterizationMode, additionalRenderSize) + LinesTestInstance (Context& context, PrimitiveWideness wideness, PrimitiveStrictness strictness, VkSampleCountFlagBits sampleCount, LineStipple stipple, VkLineRasterizationModeEXT lineRasterizationMode, deUint32 additionalRenderSize = 0) + : BaseLineTestInstance(context, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, wideness, strictness, sampleCount, stipple, lineRasterizationMode, additionalRenderSize) {} virtual void generateLines (int iteration, std::vector& outData, std::vector& outLines); @@ -2274,8 +2353,8 @@ void LinesTestInstance::generateLines (int iteration, std::vector& ou class LineStripTestInstance : public BaseLineTestInstance { public: - LineStripTestInstance (Context& context, PrimitiveWideness wideness, VkSampleCountFlagBits sampleCount, LineStipple stipple, VkLineRasterizationModeEXT lineRasterizationMode, deUint32) - : BaseLineTestInstance(context, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, wideness, sampleCount, stipple, lineRasterizationMode) + LineStripTestInstance (Context& context, PrimitiveWideness wideness, PrimitiveStrictness strictness, VkSampleCountFlagBits sampleCount, LineStipple stipple, VkLineRasterizationModeEXT lineRasterizationMode, deUint32) + : BaseLineTestInstance(context, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, wideness, strictness, sampleCount, stipple, lineRasterizationMode) {} virtual void generateLines (int iteration, std::vector& outData, std::vector& outLines); @@ -3647,7 +3726,7 @@ protected: class LineInterpolationTestInstance : public BaseRenderingTestInstance { public: - LineInterpolationTestInstance (Context& context, VkPrimitiveTopology primitiveTopology, int flags, PrimitiveWideness wideness, VkSampleCountFlagBits sampleCount); + LineInterpolationTestInstance (Context& context, VkPrimitiveTopology primitiveTopology, int flags, PrimitiveWideness wideness, PrimitiveStrictness strictness, VkSampleCountFlagBits sampleCount); virtual tcu::TestStatus iterate (void); @@ -3666,9 +3745,10 @@ private: float m_maxLineWidth; std::vector m_lineWidths; bool m_flatshade; + PrimitiveStrictness m_strictness; }; -LineInterpolationTestInstance::LineInterpolationTestInstance (Context& context, VkPrimitiveTopology primitiveTopology, int flags, PrimitiveWideness wideness, VkSampleCountFlagBits sampleCount) +LineInterpolationTestInstance::LineInterpolationTestInstance (Context& context, VkPrimitiveTopology primitiveTopology, int flags, PrimitiveWideness wideness, PrimitiveStrictness strictness, VkSampleCountFlagBits sampleCount) : BaseRenderingTestInstance (context, sampleCount) , m_primitiveTopology (primitiveTopology) , m_projective ((flags & INTERPOLATIONFLAGS_PROJECTED) != 0) @@ -3678,6 +3758,7 @@ LineInterpolationTestInstance::LineInterpolationTestInstance (Context& context, , m_allIterationsPassed (true) , m_maxLineWidth (1.0f) , m_flatshade ((flags & INTERPOLATIONFLAGS_FLATSHADE) != 0) + , m_strictness (strictness) { DE_ASSERT(m_primitiveWideness < PRIMITIVEWIDENESS_LAST); @@ -3749,8 +3830,28 @@ tcu::TestStatus LineInterpolationTestInstance::iterate (void) scene.lines.swap(lines); scene.lineWidth = getLineWidth(); - if (!verifyTriangulatedLineGroupInterpolation(resultImage, scene, args, m_context.getTestContext().getLog())) - m_allIterationsPassed = false; + switch (m_strictness) + { + case PRIMITIVESTRICTNESS_STRICT: + { + if (!verifyTriangulatedLineGroupInterpolation(resultImage, scene, args, m_context.getTestContext().getLog(), true)) + m_allIterationsPassed = false; + + break; + } + + case PRIMITIVESTRICTNESS_NONSTRICT: + case PRIMITIVESTRICTNESS_IGNORE: + { + if (!verifyTriangulatedLineGroupInterpolation(resultImage, scene, args, m_context.getTestContext().getLog(), false)) + m_allIterationsPassed = false; + + break; + } + + default: + TCU_THROW(InternalError, "Not implemented"); + } } } else @@ -3870,21 +3971,30 @@ float LineInterpolationTestInstance::getLineWidth (void) const class LineInterpolationTestCase : public BaseRenderingTestCase { public: - LineInterpolationTestCase (tcu::TestContext& context, const std::string& name, const std::string& description, VkPrimitiveTopology primitiveTopology, int flags, PrimitiveWideness wideness, VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT) + LineInterpolationTestCase (tcu::TestContext& context, + const std::string& name, + const std::string& description, + VkPrimitiveTopology primitiveTopology, + int flags, + PrimitiveWideness wideness, + PrimitiveStrictness strictness, + VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT) : BaseRenderingTestCase (context, name, description, sampleCount, (flags & INTERPOLATIONFLAGS_FLATSHADE) != 0) , m_primitiveTopology (primitiveTopology) , m_flags (flags) , m_wideness (wideness) + , m_strictness (strictness) {} virtual TestInstance* createInstance (Context& context) const { - return new LineInterpolationTestInstance(context, m_primitiveTopology, m_flags, m_wideness, m_sampleCount); + return new LineInterpolationTestInstance(context, m_primitiveTopology, m_flags, m_wideness, m_strictness, m_sampleCount); } virtual void checkSupport (Context& context) const { - if (!context.getDeviceProperties().limits.strictLines) + if (m_strictness == PRIMITIVESTRICTNESS_STRICT && + !context.getDeviceProperties().limits.strictLines) TCU_THROW(NotSupportedError, "Strict rasterization is not supported"); if (m_wideness == PRIMITIVEWIDENESS_WIDE) @@ -3894,6 +4004,7 @@ protected: const VkPrimitiveTopology m_primitiveTopology; const int m_flags; const PrimitiveWideness m_wideness; + const PrimitiveStrictness m_strictness; }; void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) @@ -3917,7 +4028,17 @@ void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) nostippleTests->addChild(new BaseTestCase (testCtx, "triangles", "Render primitives as VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, verify rasterization result")); nostippleTests->addChild(new BaseTestCase (testCtx, "triangle_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, verify rasterization result")); nostippleTests->addChild(new BaseTestCase (testCtx, "triangle_fan", "Render primitives as VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, verify rasterization result")); - nostippleTests->addChild(new WidenessTestCase (testCtx, "points", "Render primitives as VK_PRIMITIVE_TOPOLOGY_POINT_LIST, verify rasterization result", PRIMITIVEWIDENESS_WIDE, false, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "points", "Render primitives as VK_PRIMITIVE_TOPOLOGY_POINT_LIST, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, false, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + + nostippleTests->addChild(new WidenessTestCase (testCtx, "strict_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST in strict mode, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT, true, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "strict_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP in strict mode, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT, true, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "strict_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST in strict mode with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT, true, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "strict_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP in strict mode with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT, true, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + + nostippleTests->addChild(new WidenessTestCase (testCtx, "non_strict_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST in nonstrict mode, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT, true, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "non_strict_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP in nonstrict mode, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT, true, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "non_strict_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST in nonstrict mode with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT, true, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "non_strict_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP in nonstrict mode with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT, true, VK_SAMPLE_COUNT_1_BIT, LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); for (int i = 0; i < 3; ++i) { @@ -3925,25 +4046,25 @@ void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) LineStipple stipple = (LineStipple)i; - g->addChild(new WidenessTestCase (testCtx, "lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, i == 0 ? RESOLUTION_NPOT : 0)); - g->addChild(new WidenessTestCase (testCtx, "line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); - g->addChild(new WidenessTestCase (testCtx, "lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); - g->addChild(new WidenessTestCase (testCtx, "line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); - - g->addChild(new WidenessTestCase (testCtx, "rectangular_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); - g->addChild(new WidenessTestCase (testCtx, "rectangular_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); - g->addChild(new WidenessTestCase (testCtx, "rectangular_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); - g->addChild(new WidenessTestCase (testCtx, "rectangular_line_strip_wide","Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); - - g->addChild(new WidenessTestCase (testCtx, "bresenham_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); - g->addChild(new WidenessTestCase (testCtx, "bresenham_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); - g->addChild(new WidenessTestCase (testCtx, "bresenham_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); - g->addChild(new WidenessTestCase (testCtx, "bresenham_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); - - g->addChild(new WidenessTestCase (testCtx, "smooth_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); - g->addChild(new WidenessTestCase (testCtx, "smooth_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); - g->addChild(new WidenessTestCase (testCtx, "smooth_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); - g->addChild(new WidenessTestCase (testCtx, "smooth_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); + g->addChild(new WidenessTestCase (testCtx, "lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, i == 0 ? RESOLUTION_NPOT : 0)); + g->addChild(new WidenessTestCase (testCtx, "line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + g->addChild(new WidenessTestCase (testCtx, "lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + g->addChild(new WidenessTestCase (testCtx, "line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + + g->addChild(new WidenessTestCase (testCtx, "rectangular_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); + g->addChild(new WidenessTestCase (testCtx, "rectangular_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); + g->addChild(new WidenessTestCase (testCtx, "rectangular_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); + g->addChild(new WidenessTestCase (testCtx, "rectangular_line_strip_wide","Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); + + g->addChild(new WidenessTestCase (testCtx, "bresenham_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); + g->addChild(new WidenessTestCase (testCtx, "bresenham_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); + g->addChild(new WidenessTestCase (testCtx, "bresenham_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); + g->addChild(new WidenessTestCase (testCtx, "bresenham_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); + + g->addChild(new WidenessTestCase (testCtx, "smooth_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); + g->addChild(new WidenessTestCase (testCtx, "smooth_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); + g->addChild(new WidenessTestCase (testCtx, "smooth_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); + g->addChild(new WidenessTestCase (testCtx, "smooth_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, VK_SAMPLE_COUNT_1_BIT, stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); } } @@ -4118,10 +4239,20 @@ void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) basic->addChild(new TriangleInterpolationTestCase (testCtx, "triangles", "Verify triangle interpolation", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, INTERPOLATIONFLAGS_NONE)); basic->addChild(new TriangleInterpolationTestCase (testCtx, "triangle_strip", "Verify triangle strip interpolation", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, INTERPOLATIONFLAGS_NONE)); basic->addChild(new TriangleInterpolationTestCase (testCtx, "triangle_fan", "Verify triangle fan interpolation", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, INTERPOLATIONFLAGS_NONE)); - basic->addChild(new LineInterpolationTestCase (testCtx, "lines", "Verify line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW)); - basic->addChild(new LineInterpolationTestCase (testCtx, "line_strip", "Verify line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW)); - basic->addChild(new LineInterpolationTestCase (testCtx, "lines_wide", "Verify wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE)); - basic->addChild(new LineInterpolationTestCase (testCtx, "line_strip_wide","Verify wide line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE)); + basic->addChild(new LineInterpolationTestCase (testCtx, "lines", "Verify line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE)); + basic->addChild(new LineInterpolationTestCase (testCtx, "line_strip", "Verify line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE)); + basic->addChild(new LineInterpolationTestCase (testCtx, "lines_wide", "Verify wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE)); + basic->addChild(new LineInterpolationTestCase (testCtx, "line_strip_wide","Verify wide line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE)); + + basic->addChild(new LineInterpolationTestCase (testCtx, "strict_lines", "Verify strict line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT)); + basic->addChild(new LineInterpolationTestCase (testCtx, "strict_line_strip", "Verify strict line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT)); + basic->addChild(new LineInterpolationTestCase (testCtx, "strict_lines_wide", "Verify strict wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT)); + basic->addChild(new LineInterpolationTestCase (testCtx, "strict_line_strip_wide", "Verify strict wide line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT)); + + basic->addChild(new LineInterpolationTestCase (testCtx, "non_strict_lines", "Verify non-strict line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT)); + basic->addChild(new LineInterpolationTestCase (testCtx, "non_strict_line_strip", "Verify non-strict line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT)); + basic->addChild(new LineInterpolationTestCase (testCtx, "non_strict_lines_wide", "Verify non-strict wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT)); + basic->addChild(new LineInterpolationTestCase (testCtx, "non_strict_line_strip_wide", "Verify non-strict wide line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT)); } // .projected @@ -4133,10 +4264,20 @@ void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) projected->addChild(new TriangleInterpolationTestCase (testCtx, "triangles", "Verify triangle interpolation", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, INTERPOLATIONFLAGS_PROJECTED)); projected->addChild(new TriangleInterpolationTestCase (testCtx, "triangle_strip", "Verify triangle strip interpolation", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, INTERPOLATIONFLAGS_PROJECTED)); projected->addChild(new TriangleInterpolationTestCase (testCtx, "triangle_fan", "Verify triangle fan interpolation", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, INTERPOLATIONFLAGS_PROJECTED)); - projected->addChild(new LineInterpolationTestCase (testCtx, "lines", "Verify line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_NARROW)); - projected->addChild(new LineInterpolationTestCase (testCtx, "line_strip", "Verify line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_NARROW)); - projected->addChild(new LineInterpolationTestCase (testCtx, "lines_wide", "Verify wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_WIDE)); - projected->addChild(new LineInterpolationTestCase (testCtx, "line_strip_wide","Verify wide line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_WIDE)); + projected->addChild(new LineInterpolationTestCase (testCtx, "lines", "Verify line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE)); + projected->addChild(new LineInterpolationTestCase (testCtx, "line_strip", "Verify line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE)); + projected->addChild(new LineInterpolationTestCase (testCtx, "lines_wide", "Verify wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE)); + projected->addChild(new LineInterpolationTestCase (testCtx, "line_strip_wide","Verify wide line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE)); + + projected->addChild(new LineInterpolationTestCase (testCtx, "strict_lines", "Verify strict line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT)); + projected->addChild(new LineInterpolationTestCase (testCtx, "strict_line_strip", "Verify strict line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT)); + projected->addChild(new LineInterpolationTestCase (testCtx, "strict_lines_wide", "Verify strict wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT)); + projected->addChild(new LineInterpolationTestCase (testCtx, "strict_line_strip_wide", "Verify strict wide line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT)); + + projected->addChild(new LineInterpolationTestCase (testCtx, "non_strict_lines", "Verify non-strict line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT)); + projected->addChild(new LineInterpolationTestCase (testCtx, "non_strict_line_strip", "Verify non-strict line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT)); + projected->addChild(new LineInterpolationTestCase (testCtx, "non_strict_lines_wide", "Verify non-strict wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT)); + projected->addChild(new LineInterpolationTestCase (testCtx, "non_strict_line_strip_wide", "Verify non-strict wide line strip interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_PROJECTED, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT)); } } @@ -4149,10 +4290,20 @@ void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) flatshading->addChild(new TriangleInterpolationTestCase (testCtx, "triangles", "Verify triangle flatshading", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, INTERPOLATIONFLAGS_FLATSHADE)); flatshading->addChild(new TriangleInterpolationTestCase (testCtx, "triangle_strip", "Verify triangle strip flatshading", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, INTERPOLATIONFLAGS_FLATSHADE)); flatshading->addChild(new TriangleInterpolationTestCase (testCtx, "triangle_fan", "Verify triangle fan flatshading", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, INTERPOLATIONFLAGS_FLATSHADE)); - flatshading->addChild(new LineInterpolationTestCase (testCtx, "lines", "Verify line flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_NARROW)); - flatshading->addChild(new LineInterpolationTestCase (testCtx, "line_strip", "Verify line strip flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_NARROW)); - flatshading->addChild(new LineInterpolationTestCase (testCtx, "lines_wide", "Verify wide line flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_WIDE)); - flatshading->addChild(new LineInterpolationTestCase (testCtx, "line_strip_wide","Verify wide line strip flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_WIDE)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "lines", "Verify line flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "line_strip", "Verify line strip flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "lines_wide", "Verify wide line flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "line_strip_wide","Verify wide line strip flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE)); + + flatshading->addChild(new LineInterpolationTestCase (testCtx, "strict_lines", "Verify strict line flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "strict_line_strip", "Verify strict line strip flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "strict_lines_wide", "Verify strict wide line flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "strict_line_strip_wide", "Verify strict wide line strip flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT)); + + flatshading->addChild(new LineInterpolationTestCase (testCtx, "non_strict_lines", "Verify non-strict line flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "non_strict_line_strip", "Verify non-strict line strip flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "non_strict_lines_wide", "Verify non-strict wide line flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT)); + flatshading->addChild(new LineInterpolationTestCase (testCtx, "non_strict_line_strip_wide", "Verify non-strict wide line strip flatshading", VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, INTERPOLATIONFLAGS_FLATSHADE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT)); } const VkSampleCountFlagBits samples[] = @@ -4186,7 +4337,13 @@ void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) primitives->addChild(stippleDynamicTests); nostippleTests->addChild(new BaseTestCase (testCtx, "triangles", "Render primitives as VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, verify rasterization result", samples[samplesNdx])); - nostippleTests->addChild(new WidenessTestCase (testCtx, "points", "Render primitives as VK_PRIMITIVE_TOPOLOGY_POINT_LIST, verify rasterization result", PRIMITIVEWIDENESS_WIDE, false, samples[samplesNdx], LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "points", "Render primitives as VK_PRIMITIVE_TOPOLOGY_POINT_LIST, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, false, samples[samplesNdx], LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + + nostippleTests->addChild(new WidenessTestCase (testCtx, "strict_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST in strict mode, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT, true, samples[samplesNdx], LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "strict_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST in strict mode with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT, true, samples[samplesNdx], LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + + nostippleTests->addChild(new WidenessTestCase (testCtx, "non_strict_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST in nonstrict mode, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT, true, samples[samplesNdx], LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); + nostippleTests->addChild(new WidenessTestCase (testCtx, "non_strict_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST in nonstrict mode with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT, true, samples[samplesNdx], LINESTIPPLE_DISABLED, VK_LINE_RASTERIZATION_MODE_EXT_LAST)); for (int i = 0; i < 3; ++i) { @@ -4194,25 +4351,25 @@ void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) LineStipple stipple = (LineStipple)i; - g->addChild(new WidenessTestCase (testCtx, "lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, i == 0 ? RESOLUTION_NPOT : 0)); - g->addChild(new WidenessTestCase (testCtx, "line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); - g->addChild(new WidenessTestCase (testCtx, "lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); - g->addChild(new WidenessTestCase (testCtx, "line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); - - g->addChild(new WidenessTestCase (testCtx, "rectangular_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); - g->addChild(new WidenessTestCase (testCtx, "rectangular_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); - g->addChild(new WidenessTestCase (testCtx, "rectangular_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); - g->addChild(new WidenessTestCase (testCtx, "rectangular_line_strip_wide","Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); - - g->addChild(new WidenessTestCase (testCtx, "bresenham_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); - g->addChild(new WidenessTestCase (testCtx, "bresenham_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); - g->addChild(new WidenessTestCase (testCtx, "bresenham_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); - g->addChild(new WidenessTestCase (testCtx, "bresenham_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); - - g->addChild(new WidenessTestCase (testCtx, "smooth_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); - g->addChild(new WidenessTestCase (testCtx, "smooth_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); - g->addChild(new WidenessTestCase (testCtx, "smooth_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); - g->addChild(new WidenessTestCase (testCtx, "smooth_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); + g->addChild(new WidenessTestCase (testCtx, "lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, i == 0 ? RESOLUTION_NPOT : 0)); + g->addChild(new WidenessTestCase (testCtx, "line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + g->addChild(new WidenessTestCase (testCtx, "lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + g->addChild(new WidenessTestCase (testCtx, "line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT)); + + g->addChild(new WidenessTestCase (testCtx, "rectangular_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); + g->addChild(new WidenessTestCase (testCtx, "rectangular_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); + g->addChild(new WidenessTestCase (testCtx, "rectangular_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); + g->addChild(new WidenessTestCase (testCtx, "rectangular_line_strip_wide","Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT)); + + g->addChild(new WidenessTestCase (testCtx, "bresenham_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); + g->addChild(new WidenessTestCase (testCtx, "bresenham_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); + g->addChild(new WidenessTestCase (testCtx, "bresenham_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); + g->addChild(new WidenessTestCase (testCtx, "bresenham_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT)); + + g->addChild(new WidenessTestCase (testCtx, "smooth_lines", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); + g->addChild(new WidenessTestCase (testCtx, "smooth_line_strip", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, verify rasterization result", PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); + g->addChild(new WidenessTestCase (testCtx, "smooth_lines_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_LIST with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); + g->addChild(new WidenessTestCase (testCtx, "smooth_line_strip_wide", "Render primitives as VK_PRIMITIVE_TOPOLOGY_LINE_STRIP with wide lines, verify rasterization result", PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, true, samples[samplesNdx], stipple, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)); } } @@ -4235,9 +4392,15 @@ void createRasterizationTests (tcu::TestCaseGroup* rasterizationTests) rasterizationTests->addChild(interpolation); - interpolation->addChild(new TriangleInterpolationTestCase (testCtx, "triangles", "Verify triangle interpolation", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, INTERPOLATIONFLAGS_NONE, samples[samplesNdx])); - interpolation->addChild(new LineInterpolationTestCase (testCtx, "lines", "Verify line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, samples[samplesNdx])); - interpolation->addChild(new LineInterpolationTestCase (testCtx, "lines_wide", "Verify wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, samples[samplesNdx])); + interpolation->addChild(new TriangleInterpolationTestCase (testCtx, "triangles", "Verify triangle interpolation", VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, INTERPOLATIONFLAGS_NONE, samples[samplesNdx])); + interpolation->addChild(new LineInterpolationTestCase (testCtx, "lines", "Verify line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_IGNORE, samples[samplesNdx])); + interpolation->addChild(new LineInterpolationTestCase (testCtx, "lines_wide", "Verify wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_IGNORE, samples[samplesNdx])); + + interpolation->addChild(new LineInterpolationTestCase (testCtx, "strict_lines", "Verify strict line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_STRICT, samples[samplesNdx])); + interpolation->addChild(new LineInterpolationTestCase (testCtx, "strict_lines_wide", "Verify strict wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_STRICT, samples[samplesNdx])); + + interpolation->addChild(new LineInterpolationTestCase (testCtx, "non_strict_lines", "Verify non-strict line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_NARROW, PRIMITIVESTRICTNESS_NONSTRICT, samples[samplesNdx])); + interpolation->addChild(new LineInterpolationTestCase (testCtx, "non_strict_lines_wide", "Verify non-strict wide line interpolation", VK_PRIMITIVE_TOPOLOGY_LINE_LIST, INTERPOLATIONFLAGS_NONE, PRIMITIVEWIDENESS_WIDE, PRIMITIVESTRICTNESS_NONSTRICT, samples[samplesNdx])); } } diff --git a/external/vulkancts/mustpass/master/src/excluded-tests.txt b/external/vulkancts/mustpass/master/src/excluded-tests.txt index 2d2dc32..160f3df 100644 --- a/external/vulkancts/mustpass/master/src/excluded-tests.txt +++ b/external/vulkancts/mustpass/master/src/excluded-tests.txt @@ -15,4 +15,9 @@ dEQP-VK.pipeline.multisample.*.primitive_point_1px_sparse # VK-GL-CTS 1829 # Test shader length is excessive, excluding until such time as the test case can be re-visited. -dEQP-VK.ssbo.layout.random.scalar.75 \ No newline at end of file +dEQP-VK.ssbo.layout.random.scalar.75 + +# VK-GL-CTS 1024 +dEQP-VK.rasterization.interpolation_multisample_16_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.non_strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.non_strict_lines_wide diff --git a/external/vulkancts/mustpass/master/vk-default-no-waivers.txt b/external/vulkancts/mustpass/master/vk-default-no-waivers.txt index 18cb4e6..73512ef 100644 --- a/external/vulkancts/mustpass/master/vk-default-no-waivers.txt +++ b/external/vulkancts/mustpass/master/vk-default-no-waivers.txt @@ -504629,6 +504629,14 @@ dEQP-VK.rasterization.primitives.no_stipple.triangles dEQP-VK.rasterization.primitives.no_stipple.triangle_strip dEQP-VK.rasterization.primitives.no_stipple.triangle_fan dEQP-VK.rasterization.primitives.no_stipple.points +dEQP-VK.rasterization.primitives.no_stipple.strict_lines +dEQP-VK.rasterization.primitives.no_stipple.strict_line_strip +dEQP-VK.rasterization.primitives.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives.no_stipple.strict_line_strip_wide +dEQP-VK.rasterization.primitives.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives.no_stipple.non_strict_line_strip +dEQP-VK.rasterization.primitives.no_stipple.non_strict_lines_wide +dEQP-VK.rasterization.primitives.no_stipple.non_strict_line_strip_wide dEQP-VK.rasterization.primitives.no_stipple.lines dEQP-VK.rasterization.primitives.no_stipple.line_strip dEQP-VK.rasterization.primitives.no_stipple.lines_wide @@ -504750,20 +504758,48 @@ dEQP-VK.rasterization.interpolation.basic.triangle_fan dEQP-VK.rasterization.interpolation.basic.lines dEQP-VK.rasterization.interpolation.basic.line_strip dEQP-VK.rasterization.interpolation.basic.line_strip_wide +dEQP-VK.rasterization.interpolation.basic.strict_lines +dEQP-VK.rasterization.interpolation.basic.strict_line_strip +dEQP-VK.rasterization.interpolation.basic.strict_lines_wide +dEQP-VK.rasterization.interpolation.basic.strict_line_strip_wide +dEQP-VK.rasterization.interpolation.basic.non_strict_lines +dEQP-VK.rasterization.interpolation.basic.non_strict_line_strip +dEQP-VK.rasterization.interpolation.basic.non_strict_lines_wide +dEQP-VK.rasterization.interpolation.basic.non_strict_line_strip_wide dEQP-VK.rasterization.interpolation.projected.triangles dEQP-VK.rasterization.interpolation.projected.triangle_strip dEQP-VK.rasterization.interpolation.projected.triangle_fan dEQP-VK.rasterization.interpolation.projected.lines dEQP-VK.rasterization.interpolation.projected.line_strip dEQP-VK.rasterization.interpolation.projected.lines_wide +dEQP-VK.rasterization.interpolation.projected.strict_lines +dEQP-VK.rasterization.interpolation.projected.strict_line_strip +dEQP-VK.rasterization.interpolation.projected.strict_lines_wide +dEQP-VK.rasterization.interpolation.projected.strict_line_strip_wide +dEQP-VK.rasterization.interpolation.projected.non_strict_lines +dEQP-VK.rasterization.interpolation.projected.non_strict_line_strip +dEQP-VK.rasterization.interpolation.projected.non_strict_lines_wide +dEQP-VK.rasterization.interpolation.projected.non_strict_line_strip_wide dEQP-VK.rasterization.flatshading.triangles dEQP-VK.rasterization.flatshading.triangle_strip dEQP-VK.rasterization.flatshading.triangle_fan dEQP-VK.rasterization.flatshading.lines dEQP-VK.rasterization.flatshading.line_strip dEQP-VK.rasterization.flatshading.line_strip_wide +dEQP-VK.rasterization.flatshading.strict_lines +dEQP-VK.rasterization.flatshading.strict_line_strip +dEQP-VK.rasterization.flatshading.strict_lines_wide +dEQP-VK.rasterization.flatshading.strict_line_strip_wide +dEQP-VK.rasterization.flatshading.non_strict_lines +dEQP-VK.rasterization.flatshading.non_strict_line_strip +dEQP-VK.rasterization.flatshading.non_strict_lines_wide +dEQP-VK.rasterization.flatshading.non_strict_line_strip_wide dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.lines_wide @@ -504820,8 +504856,16 @@ dEQP-VK.rasterization.fill_rules_multisample_2_bit.projected dEQP-VK.rasterization.interpolation_multisample_2_bit.triangles dEQP-VK.rasterization.interpolation_multisample_2_bit.lines dEQP-VK.rasterization.interpolation_multisample_2_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_2_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_2_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_2_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_2_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.lines_wide @@ -504878,8 +504922,16 @@ dEQP-VK.rasterization.fill_rules_multisample_4_bit.projected dEQP-VK.rasterization.interpolation_multisample_4_bit.triangles dEQP-VK.rasterization.interpolation_multisample_4_bit.lines dEQP-VK.rasterization.interpolation_multisample_4_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_4_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_4_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_4_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_4_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.lines_wide @@ -504936,8 +504988,15 @@ dEQP-VK.rasterization.fill_rules_multisample_8_bit.projected dEQP-VK.rasterization.interpolation_multisample_8_bit.triangles dEQP-VK.rasterization.interpolation_multisample_8_bit.lines dEQP-VK.rasterization.interpolation_multisample_8_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_8_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_8_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_8_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_8_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.non_strict_lines dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.lines_wide @@ -504993,9 +505052,15 @@ dEQP-VK.rasterization.fill_rules_multisample_16_bit.clipped_partly dEQP-VK.rasterization.fill_rules_multisample_16_bit.projected dEQP-VK.rasterization.interpolation_multisample_16_bit.triangles dEQP-VK.rasterization.interpolation_multisample_16_bit.lines -dEQP-VK.rasterization.interpolation_multisample_16_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_16_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.non_strict_lines dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.lines_wide @@ -505052,8 +505117,16 @@ dEQP-VK.rasterization.fill_rules_multisample_32_bit.projected dEQP-VK.rasterization.interpolation_multisample_32_bit.triangles dEQP-VK.rasterization.interpolation_multisample_32_bit.lines dEQP-VK.rasterization.interpolation_multisample_32_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_32_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_32_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_32_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_32_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.lines_wide @@ -505110,6 +505183,10 @@ dEQP-VK.rasterization.fill_rules_multisample_64_bit.projected dEQP-VK.rasterization.interpolation_multisample_64_bit.triangles dEQP-VK.rasterization.interpolation_multisample_64_bit.lines dEQP-VK.rasterization.interpolation_multisample_64_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_64_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_64_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_64_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_64_bit.non_strict_lines_wide dEQP-VK.rasterization.provoking_vertex.triangle_list dEQP-VK.rasterization.provoking_vertex.triangle_list_with_adjacency dEQP-VK.rasterization.provoking_vertex.triangle_strip diff --git a/external/vulkancts/mustpass/master/vk-default.txt b/external/vulkancts/mustpass/master/vk-default.txt index b0acfc5..c2f97fb 100644 --- a/external/vulkancts/mustpass/master/vk-default.txt +++ b/external/vulkancts/mustpass/master/vk-default.txt @@ -504590,6 +504590,14 @@ dEQP-VK.rasterization.primitives.no_stipple.triangles dEQP-VK.rasterization.primitives.no_stipple.triangle_strip dEQP-VK.rasterization.primitives.no_stipple.triangle_fan dEQP-VK.rasterization.primitives.no_stipple.points +dEQP-VK.rasterization.primitives.no_stipple.strict_lines +dEQP-VK.rasterization.primitives.no_stipple.strict_line_strip +dEQP-VK.rasterization.primitives.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives.no_stipple.strict_line_strip_wide +dEQP-VK.rasterization.primitives.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives.no_stipple.non_strict_line_strip +dEQP-VK.rasterization.primitives.no_stipple.non_strict_lines_wide +dEQP-VK.rasterization.primitives.no_stipple.non_strict_line_strip_wide dEQP-VK.rasterization.primitives.no_stipple.lines dEQP-VK.rasterization.primitives.no_stipple.line_strip dEQP-VK.rasterization.primitives.no_stipple.lines_wide @@ -504711,20 +504719,48 @@ dEQP-VK.rasterization.interpolation.basic.triangle_fan dEQP-VK.rasterization.interpolation.basic.lines dEQP-VK.rasterization.interpolation.basic.line_strip dEQP-VK.rasterization.interpolation.basic.line_strip_wide +dEQP-VK.rasterization.interpolation.basic.strict_lines +dEQP-VK.rasterization.interpolation.basic.strict_line_strip +dEQP-VK.rasterization.interpolation.basic.strict_lines_wide +dEQP-VK.rasterization.interpolation.basic.strict_line_strip_wide +dEQP-VK.rasterization.interpolation.basic.non_strict_lines +dEQP-VK.rasterization.interpolation.basic.non_strict_line_strip +dEQP-VK.rasterization.interpolation.basic.non_strict_lines_wide +dEQP-VK.rasterization.interpolation.basic.non_strict_line_strip_wide dEQP-VK.rasterization.interpolation.projected.triangles dEQP-VK.rasterization.interpolation.projected.triangle_strip dEQP-VK.rasterization.interpolation.projected.triangle_fan dEQP-VK.rasterization.interpolation.projected.lines dEQP-VK.rasterization.interpolation.projected.line_strip dEQP-VK.rasterization.interpolation.projected.lines_wide +dEQP-VK.rasterization.interpolation.projected.strict_lines +dEQP-VK.rasterization.interpolation.projected.strict_line_strip +dEQP-VK.rasterization.interpolation.projected.strict_lines_wide +dEQP-VK.rasterization.interpolation.projected.strict_line_strip_wide +dEQP-VK.rasterization.interpolation.projected.non_strict_lines +dEQP-VK.rasterization.interpolation.projected.non_strict_line_strip +dEQP-VK.rasterization.interpolation.projected.non_strict_lines_wide +dEQP-VK.rasterization.interpolation.projected.non_strict_line_strip_wide dEQP-VK.rasterization.flatshading.triangles dEQP-VK.rasterization.flatshading.triangle_strip dEQP-VK.rasterization.flatshading.triangle_fan dEQP-VK.rasterization.flatshading.lines dEQP-VK.rasterization.flatshading.line_strip dEQP-VK.rasterization.flatshading.line_strip_wide +dEQP-VK.rasterization.flatshading.strict_lines +dEQP-VK.rasterization.flatshading.strict_line_strip +dEQP-VK.rasterization.flatshading.strict_lines_wide +dEQP-VK.rasterization.flatshading.strict_line_strip_wide +dEQP-VK.rasterization.flatshading.non_strict_lines +dEQP-VK.rasterization.flatshading.non_strict_line_strip +dEQP-VK.rasterization.flatshading.non_strict_lines_wide +dEQP-VK.rasterization.flatshading.non_strict_line_strip_wide dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_2_bit.no_stipple.lines_wide @@ -504781,8 +504817,16 @@ dEQP-VK.rasterization.fill_rules_multisample_2_bit.projected dEQP-VK.rasterization.interpolation_multisample_2_bit.triangles dEQP-VK.rasterization.interpolation_multisample_2_bit.lines dEQP-VK.rasterization.interpolation_multisample_2_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_2_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_2_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_2_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_2_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_4_bit.no_stipple.lines_wide @@ -504839,8 +504883,16 @@ dEQP-VK.rasterization.fill_rules_multisample_4_bit.projected dEQP-VK.rasterization.interpolation_multisample_4_bit.triangles dEQP-VK.rasterization.interpolation_multisample_4_bit.lines dEQP-VK.rasterization.interpolation_multisample_4_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_4_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_4_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_4_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_4_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_8_bit.no_stipple.lines_wide @@ -504897,8 +504949,15 @@ dEQP-VK.rasterization.fill_rules_multisample_8_bit.projected dEQP-VK.rasterization.interpolation_multisample_8_bit.triangles dEQP-VK.rasterization.interpolation_multisample_8_bit.lines dEQP-VK.rasterization.interpolation_multisample_8_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_8_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_8_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_8_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_8_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.non_strict_lines dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_16_bit.no_stipple.lines_wide @@ -504954,9 +505013,15 @@ dEQP-VK.rasterization.fill_rules_multisample_16_bit.clipped_partly dEQP-VK.rasterization.fill_rules_multisample_16_bit.projected dEQP-VK.rasterization.interpolation_multisample_16_bit.triangles dEQP-VK.rasterization.interpolation_multisample_16_bit.lines -dEQP-VK.rasterization.interpolation_multisample_16_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_16_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_16_bit.non_strict_lines dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_32_bit.no_stipple.lines_wide @@ -505013,8 +505078,16 @@ dEQP-VK.rasterization.fill_rules_multisample_32_bit.projected dEQP-VK.rasterization.interpolation_multisample_32_bit.triangles dEQP-VK.rasterization.interpolation_multisample_32_bit.lines dEQP-VK.rasterization.interpolation_multisample_32_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_32_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_32_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_32_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_32_bit.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.triangles dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.points +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.strict_lines +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.strict_lines_wide +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.non_strict_lines +dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.non_strict_lines_wide dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.lines dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.line_strip dEQP-VK.rasterization.primitives_multisample_64_bit.no_stipple.lines_wide @@ -505071,6 +505144,10 @@ dEQP-VK.rasterization.fill_rules_multisample_64_bit.projected dEQP-VK.rasterization.interpolation_multisample_64_bit.triangles dEQP-VK.rasterization.interpolation_multisample_64_bit.lines dEQP-VK.rasterization.interpolation_multisample_64_bit.lines_wide +dEQP-VK.rasterization.interpolation_multisample_64_bit.strict_lines +dEQP-VK.rasterization.interpolation_multisample_64_bit.strict_lines_wide +dEQP-VK.rasterization.interpolation_multisample_64_bit.non_strict_lines +dEQP-VK.rasterization.interpolation_multisample_64_bit.non_strict_lines_wide dEQP-VK.rasterization.provoking_vertex.triangle_list dEQP-VK.rasterization.provoking_vertex.triangle_list_with_adjacency dEQP-VK.rasterization.provoking_vertex.triangle_strip diff --git a/framework/common/tcuRasterizationVerifier.cpp b/framework/common/tcuRasterizationVerifier.cpp index 3945bce..8fe7cf3 100644 --- a/framework/common/tcuRasterizationVerifier.cpp +++ b/framework/common/tcuRasterizationVerifier.cpp @@ -28,7 +28,9 @@ #include "tcuTextureUtil.hpp" #include "tcuVectorUtil.hpp" #include "tcuFloat.hpp" + #include "deMath.h" +#include "deStringUtil.hpp" #include "rrRasterizer.hpp" @@ -651,7 +653,11 @@ struct MultisampleLineInterpolator }; template -bool verifyTriangleGroupInterpolationWithInterpolator (const tcu::Surface& surface, const TriangleSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const Interpolator& interpolator) +bool verifyTriangleGroupInterpolationWithInterpolator (const tcu::Surface& surface, + const TriangleSceneSpec& scene, + const RasterizationArguments& args, + VerifyTriangleGroupInterpolationLogStash& logStash, + const Interpolator& interpolator) { const tcu::RGBA invalidPixelColor = tcu::RGBA(255, 0, 0, 255); const bool multisampled = (args.numSamples != 0); @@ -666,21 +672,22 @@ bool verifyTriangleGroupInterpolationWithInterpolator (const tcu::Surface& surfa // log format - log << tcu::TestLog::Message << "Verifying rasterization result. Native format is RGB" << args.redBits << args.greenBits << args.blueBits << tcu::TestLog::EndMessage; + logStash.messages.push_back(std::string("Verifying rasterization result. Native format is RGB" + de::toString(args.redBits) + de::toString(args.greenBits) + de::toString(args.blueBits))); if (args.redBits > 8 || args.greenBits > 8 || args.blueBits > 8) - log << tcu::TestLog::Message << "Warning! More than 8 bits in a color channel, this may produce false negatives." << tcu::TestLog::EndMessage; + logStash.messages.push_back(std::string("Warning! More than 8 bits in a color channel, this may produce false negatives.")); // subpixel bits in a valid range? if (subPixelBits < 0) { - log << tcu::TestLog::Message << "Invalid subpixel count (" << subPixelBits << "), assuming 0" << tcu::TestLog::EndMessage; + logStash.messages.push_back(std::string("Invalid subpixel count (" + de::toString(subPixelBits) + "), assuming 0")); subPixelBits = 0; } else if (subPixelBits > 16) { // At high subpixel bit counts we might overflow. Checking at lower bit count is ok, but is less strict - log << tcu::TestLog::Message << "Subpixel count is greater than 16 (" << subPixelBits << "). Checking results using less strict 16 bit requirements. This may produce false positives." << tcu::TestLog::EndMessage; + logStash.messages.push_back(std::string("Subpixel count is greater than 16 (" + de::toString(subPixelBits) + ")." + " Checking results using less strict 16 bit requirements. This may produce false positives.")); subPixelBits = 16; } @@ -763,11 +770,13 @@ bool verifyTriangleGroupInterpolationWithInterpolator (const tcu::Surface& surfa // don't fill the logs with too much data if (errorCount < errorFloodThreshold) { - log << tcu::TestLog::Message - << "Found an invalid pixel at (" << x << "," << y << ")\n" + std::ostringstream str; + + str << "Found an invalid pixel at (" << x << "," << y << ")\n" << "\tPixel color:\t\t" << color << "\n" - << "\tExpected background color.\n" - << tcu::TestLog::EndMessage; + << "\tExpected background color.\n"; + + logStash.messages.push_back(str.str()); } ++invalidPixels; @@ -816,8 +825,9 @@ bool verifyTriangleGroupInterpolationWithInterpolator (const tcu::Surface& surfa // don't fill the logs with too much data if (errorCount <= errorFloodThreshold) { - log << tcu::TestLog::Message - << "Found an invalid pixel at (" << x << "," << y << ")\n" + std::ostringstream str; + + str << "Found an invalid pixel at (" << x << "," << y << ")\n" << "\tPixel color:\t\t" << color << "\n" << "\tNative color:\t\t" << pixelNativeColor << "\n" << "\tAllowed error:\t\t" << tcu::IVec3(thresholdRed, thresholdGreen, thresholdBlue) << "\n" @@ -826,8 +836,8 @@ bool verifyTriangleGroupInterpolationWithInterpolator (const tcu::Surface& surfa << "\tReference native float min: " << tcu::clamp(colorMinF - tcu::IVec3(thresholdRed, thresholdGreen, thresholdBlue).cast(), tcu::Vec3(0.0f, 0.0f, 0.0f), formatLimit.cast()) << "\n" << "\tReference native float max: " << tcu::clamp(colorMaxF + tcu::IVec3(thresholdRed, thresholdGreen, thresholdBlue).cast(), tcu::Vec3(0.0f, 0.0f, 0.0f), formatLimit.cast()) << "\n" << "\tFmin:\t" << tcu::clamp(valueRangeMin, tcu::Vec3(0.0f, 0.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 1.0f)) << "\n" - << "\tFmax:\t" << tcu::clamp(valueRangeMax, tcu::Vec3(0.0f, 0.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 1.0f)) << "\n" - << tcu::TestLog::EndMessage; + << "\tFmax:\t" << tcu::clamp(valueRangeMax, tcu::Vec3(0.0f, 0.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 1.0f)) << "\n"; + logStash.messages.push_back(str.str()); } ++invalidPixels; @@ -838,28 +848,16 @@ bool verifyTriangleGroupInterpolationWithInterpolator (const tcu::Surface& surfa // don't just hide failures if (errorCount > errorFloodThreshold) - log << tcu::TestLog::Message << "Omitted " << (errorCount-errorFloodThreshold) << " pixel error description(s)." << tcu::TestLog::EndMessage; + logStash.messages.push_back(std::string("Omitted " + de::toString(errorCount - errorFloodThreshold) + " pixel error description(s).")); - // report result - if (invalidPixels) - { - log << tcu::TestLog::Message << invalidPixels << " invalid pixel(s) found." << tcu::TestLog::EndMessage; - log << tcu::TestLog::ImageSet("Verification result", "Result of rendering") - << tcu::TestLog::Image("Result", "Result", surface) - << tcu::TestLog::Image("ErrorMask", "ErrorMask", errorMask) - << tcu::TestLog::EndImageSet; + logStash.success = (invalidPixels == 0); + logStash.invalidPixels = invalidPixels; - return false; - } - else - { - log << tcu::TestLog::Message << "No invalid pixels found." << tcu::TestLog::EndMessage; - log << tcu::TestLog::ImageSet("Verification result", "Result of rendering") - << tcu::TestLog::Image("Result", "Result", surface) - << tcu::TestLog::EndImageSet; + // report result + if (!logStash.success) + logStash.errorMask = errorMask; - return true; - } + return logStash.success; } @@ -907,7 +905,14 @@ enum ClipMode CLIPMODE_LAST }; -bool verifyMultisampleLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, ClipMode clipMode, VerifyTriangleGroupRasterizationLogStash* logStash = DE_NULL, const bool vulkanLinesTest = false) +bool verifyMultisampleLineGroupRasterization (const tcu::Surface& surface, + const LineSceneSpec& scene, + const RasterizationArguments& args, + tcu::TestLog& log, + ClipMode clipMode, + VerifyTriangleGroupRasterizationLogStash* logStash, + const bool vulkanLinesTest, + const bool strictMode) { // Multisampled line == 2 triangles @@ -948,7 +953,9 @@ bool verifyMultisampleLineGroupRasterization (const tcu::Surface& surface, const }; const tcu::Vec2 lineDir = tcu::normalize(lineScreenSpace[1] - lineScreenSpace[0]); - const tcu::Vec2 lineNormalDir = tcu::Vec2(lineDir.y(), -lineDir.x()); + const tcu::Vec2 lineNormalDir = strictMode ? tcu::Vec2(lineDir.y(), -lineDir.x()) + : isLineXMajor(lineScreenSpace[0], lineScreenSpace[1]) ? tcu::Vec2(0.0f, 1.0f) + : tcu::Vec2(1.0f, 0.0f); if (scene.stippleEnable) { @@ -1060,10 +1067,20 @@ bool verifyMultisampleLineGroupRasterization (const tcu::Surface& surface, const } } - return verifyTriangleGroupRasterization(surface, triangleScene, args, log, scene.verificationMode, logStash, vulkanLinesTest); + if (logStash != DE_NULL) + { + logStash->messages.push_back("Rasterization clipping mode: " + std::string(clipMode == CLIPMODE_USE_CLIPPING_BOX ? "CLIPMODE_USE_CLIPPING_BOX" : "CLIPMODE_NO_CLIPPING") + "."); + logStash->messages.push_back("Rasterization line draw strictness mode: " + std::string(strictMode ? "strict" : "non-strict") + "."); + } + + return verifyTriangleGroupRasterization(surface, triangleScene, args, log, VERIFICATIONMODE_STRICT, logStash, vulkanLinesTest); } -bool verifyMultisampleLineGroupInterpolation (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log) +bool verifyMultisampleLineGroupInterpolationInternal (const tcu::Surface& surface, + const LineSceneSpec& scene, + const RasterizationArguments& args, + VerifyTriangleGroupInterpolationLogStash& logStash, + const bool strictMode) { // Multisampled line == 2 triangles @@ -1087,7 +1104,9 @@ bool verifyMultisampleLineGroupInterpolation (const tcu::Surface& surface, const }; const tcu::Vec2 lineDir = tcu::normalize(lineScreenSpace[1] - lineScreenSpace[0]); - const tcu::Vec2 lineNormalDir = tcu::Vec2(lineDir.y(), -lineDir.x()); + const tcu::Vec2 lineNormalDir = strictMode ? tcu::Vec2(lineDir.y(), -lineDir.x()) + : isLineXMajor(lineScreenSpace[0], lineScreenSpace[1]) ? tcu::Vec2(0.0f, 1.0f) + : tcu::Vec2(1.0f, 0.0f); const tcu::Vec2 lineQuadScreenSpace[4] = { @@ -1129,7 +1148,76 @@ bool verifyMultisampleLineGroupInterpolation (const tcu::Surface& surface, const triangleScene.triangles[lineNdx*2 + 1].colors[2] = scene.lines[lineNdx].colors[1]; } - return verifyTriangleGroupInterpolationWithInterpolator(surface, triangleScene, args, log, MultisampleLineInterpolator(scene)); + return verifyTriangleGroupInterpolationWithInterpolator(surface, triangleScene, args, logStash, MultisampleLineInterpolator(scene)); +} + +static void logTriangleGroupnterpolationStash (const tcu::Surface& surface, tcu::TestLog& log, VerifyTriangleGroupInterpolationLogStash& logStash) +{ + // Output results + log << tcu::TestLog::Message << "Verifying rasterization result." << tcu::TestLog::EndMessage; + + for (size_t msgNdx = 0; msgNdx < logStash.messages.size(); ++msgNdx) + log << tcu::TestLog::Message << logStash.messages[msgNdx] << tcu::TestLog::EndMessage; + + // report result + if (!logStash.success) + { + log << tcu::TestLog::Message << logStash.invalidPixels << " invalid pixel(s) found." << tcu::TestLog::EndMessage; + log << tcu::TestLog::ImageSet("Verification result", "Result of rendering") + << tcu::TestLog::Image("Result", "Result", surface) + << tcu::TestLog::Image("ErrorMask", "ErrorMask", logStash.errorMask) + << tcu::TestLog::EndImageSet; + } + else + { + log << tcu::TestLog::Message << "No invalid pixels found." << tcu::TestLog::EndMessage; + log << tcu::TestLog::ImageSet("Verification result", "Result of rendering") + << tcu::TestLog::Image("Result", "Result", surface) + << tcu::TestLog::EndImageSet; + } +} + +static bool verifyMultisampleLineGroupInterpolation (const tcu::Surface& surface, + const LineSceneSpec& scene, + const RasterizationArguments& args, + tcu::TestLog& log, + const bool strictMode = true) +{ + bool result = false; + VerifyTriangleGroupInterpolationLogStash nonStrictModeLogStash; + VerifyTriangleGroupInterpolationLogStash strictModeLogStash; + + nonStrictModeLogStash.messages.push_back("Non-strict line draw mode."); + strictModeLogStash.messages.push_back("Strict mode line draw mode."); + + if (strictMode) + { + result = verifyMultisampleLineGroupInterpolationInternal(surface,scene, args, strictModeLogStash, strictMode); + + logTriangleGroupnterpolationStash(surface, log, strictModeLogStash); + } + else + { + if (verifyMultisampleLineGroupInterpolationInternal(surface,scene, args, nonStrictModeLogStash, false)) + { + logTriangleGroupnterpolationStash(surface, log, nonStrictModeLogStash); + + result = true; + } + else if (verifyMultisampleLineGroupInterpolationInternal(surface,scene, args, strictModeLogStash, true)) + { + logTriangleGroupnterpolationStash(surface, log, strictModeLogStash); + + result = true; + } + else + { + logTriangleGroupnterpolationStash(surface, log, nonStrictModeLogStash); + logTriangleGroupnterpolationStash(surface, log, strictModeLogStash); + } + } + + return result; } bool verifyMultisamplePointGroupRasterization (const tcu::Surface& surface, const PointSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log) @@ -2346,11 +2434,14 @@ CoverageType calculateTriangleCoverage (const tcu::Vec4& p0, const tcu::Vec4& p1 } } -static void verifyTriangleGroupRasterizationLog (const tcu::Surface& surface, tcu::TestLog& log, VerifyTriangleGroupRasterizationLogStash& logStash) +static void logTriangleGroupRasterizationStash (const tcu::Surface& surface, tcu::TestLog& log, VerifyTriangleGroupRasterizationLogStash& logStash) { // Output results log << tcu::TestLog::Message << "Verifying rasterization result." << tcu::TestLog::EndMessage; + for (size_t msgNdx = 0; msgNdx < logStash.messages.size(); ++msgNdx) + log << tcu::TestLog::Message << logStash.messages[msgNdx] << tcu::TestLog::EndMessage; + if (!logStash.result) { log << tcu::TestLog::Message << "Invalid pixels found:\n\t" @@ -2563,7 +2654,7 @@ bool verifyTriangleGroupRasterization (const tcu::Surface& surface, const Triang if (logStash == DE_NULL) { - verifyTriangleGroupRasterizationLog(surface, log, *tempLogStash); + logTriangleGroupRasterizationStash(surface, log, *tempLogStash); delete tempLogStash; } } @@ -2576,34 +2667,44 @@ bool verifyLineGroupRasterization (const tcu::Surface& surface, const LineSceneS const bool multisampled = args.numSamples != 0; if (multisampled) - return verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_NO_CLIPPING, DE_NULL); + return verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_NO_CLIPPING, DE_NULL, false, true); else return verifySinglesampleLineGroupRasterization(surface, scene, args, log); } bool verifyClippedTriangulatedLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log) { - return verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_USE_CLIPPING_BOX, DE_NULL); + return verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_USE_CLIPPING_BOX, DE_NULL, false, true); } -bool verifyRelaxedLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const bool vulkanLinesTest) +bool verifyRelaxedLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const bool vulkanLinesTest, const bool strict) { - VerifyTriangleGroupRasterizationLogStash noClippingLogStash; VerifyTriangleGroupRasterizationLogStash useClippingLogStash; + VerifyTriangleGroupRasterizationLogStash noClippingLogStash; + VerifyTriangleGroupRasterizationLogStash useClippingForcedStrictLogStash; + VerifyTriangleGroupRasterizationLogStash noClippingForcedStrictLogStash; - if (verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_USE_CLIPPING_BOX, &useClippingLogStash, vulkanLinesTest)) + if (verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_USE_CLIPPING_BOX, &useClippingLogStash, vulkanLinesTest, strict)) { - log << tcu::TestLog::Message << "Relaxed rasterization succeeded with CLIPMODE_USE_CLIPPING_BOX, details follow." << tcu::TestLog::EndMessage; + logTriangleGroupRasterizationStash(surface, log, useClippingLogStash); - verifyTriangleGroupRasterizationLog(surface, log, useClippingLogStash); + return true; + } + else if (verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_NO_CLIPPING, &noClippingLogStash, vulkanLinesTest, strict)) + { + logTriangleGroupRasterizationStash(surface, log, noClippingLogStash); return true; } - else if (verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_NO_CLIPPING, &noClippingLogStash, vulkanLinesTest)) + else if (strict == false && verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_USE_CLIPPING_BOX, &useClippingForcedStrictLogStash, vulkanLinesTest, true)) { - log << tcu::TestLog::Message << "Relaxed rasterization succeeded with CLIPMODE_NO_CLIPPING, details follow." << tcu::TestLog::EndMessage; + logTriangleGroupRasterizationStash(surface, log, useClippingForcedStrictLogStash); - verifyTriangleGroupRasterizationLog(surface, log, noClippingLogStash); + return true; + } + else if (strict == false && verifyMultisampleLineGroupRasterization(surface, scene, args, log, CLIPMODE_NO_CLIPPING, &noClippingForcedStrictLogStash, vulkanLinesTest, true)) + { + logTriangleGroupRasterizationStash(surface, log, noClippingForcedStrictLogStash); return true; } @@ -2611,8 +2712,14 @@ bool verifyRelaxedLineGroupRasterization (const tcu::Surface& surface, const Lin { log << tcu::TestLog::Message << "Relaxed rasterization failed, details follow." << tcu::TestLog::EndMessage; - verifyTriangleGroupRasterizationLog(surface, log, useClippingLogStash); - verifyTriangleGroupRasterizationLog(surface, log, noClippingLogStash); + logTriangleGroupRasterizationStash(surface, log, useClippingLogStash); + logTriangleGroupRasterizationStash(surface, log, noClippingLogStash); + + if (strict == false) + { + logTriangleGroupRasterizationStash(surface, log, useClippingForcedStrictLogStash); + logTriangleGroupRasterizationStash(surface, log, noClippingForcedStrictLogStash); + } return false; } @@ -2626,7 +2733,12 @@ bool verifyPointGroupRasterization (const tcu::Surface& surface, const PointScen bool verifyTriangleGroupInterpolation (const tcu::Surface& surface, const TriangleSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log) { - return verifyTriangleGroupInterpolationWithInterpolator(surface, scene, args, log, TriangleInterpolator(scene)); + VerifyTriangleGroupInterpolationLogStash logStash; + const bool result = verifyTriangleGroupInterpolationWithInterpolator(surface, scene, args, logStash, TriangleInterpolator(scene)); + + logTriangleGroupnterpolationStash(surface, log, logStash); + + return result; } LineInterpolationMethod verifyLineGroupInterpolation (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log) @@ -2664,9 +2776,9 @@ LineInterpolationMethod verifyLineGroupInterpolation (const tcu::Surface& surfac } } -bool verifyTriangulatedLineGroupInterpolation (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log) +bool verifyTriangulatedLineGroupInterpolation (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const bool strictMode) { - return verifyMultisampleLineGroupInterpolation(surface, scene, args, log); + return verifyMultisampleLineGroupInterpolation(surface, scene, args, log, strictMode); } } // tcu diff --git a/framework/common/tcuRasterizationVerifier.hpp b/framework/common/tcuRasterizationVerifier.hpp index ffff501..eb8323c 100644 --- a/framework/common/tcuRasterizationVerifier.hpp +++ b/framework/common/tcuRasterizationVerifier.hpp @@ -119,10 +119,19 @@ struct RasterizationArguments struct VerifyTriangleGroupRasterizationLogStash { - int missingPixels; - int unexpectedPixels; - tcu::Surface errorMask; - bool result; + std::vector messages; + int missingPixels; + int unexpectedPixels; + tcu::Surface errorMask; + bool result; +}; + +struct VerifyTriangleGroupInterpolationLogStash +{ + std::vector messages; + int invalidPixels; + tcu::Surface errorMask; + bool success; }; /*--------------------------------------------------------------------*//*! @@ -178,7 +187,7 @@ bool verifyClippedTriangulatedLineGroupRasterization (const tcu::Surface& surfac * * Returns false if both rasterizations are invalid. *//*--------------------------------------------------------------------*/ -bool verifyRelaxedLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const bool vulkanLinesTest = false); +bool verifyRelaxedLineGroupRasterization (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const bool vulkanLinesTest = false, const bool strict = true); /*--------------------------------------------------------------------*//*! * \brief Verify point rasterization result @@ -223,7 +232,7 @@ LineInterpolationMethod verifyLineGroupInterpolation (const tcu::Surface& surfac * * Returns false if invalid rasterization interpolation is found. *//*--------------------------------------------------------------------*/ -bool verifyTriangulatedLineGroupInterpolation (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log); +bool verifyTriangulatedLineGroupInterpolation (const tcu::Surface& surface, const LineSceneSpec& scene, const RasterizationArguments& args, tcu::TestLog& log, const bool strictMode = true); } // tcu -- 2.7.4