#include "vkTypeUtil.hpp"
#include "vkObjUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkStrUtil.hpp"
#include "vktTestGroupUtil.hpp"
#include "vktTestCase.hpp"
#include <set>
#include <string>
#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <iterator>
namespace vkt
{
NO_ATTACHMENT = 0,
NO_ATTACHMENT_PTR,
WITH_ATTACHMENT,
+ WITH_ATTACHMENT_WITHOUT_IMAGEVIEW, // No imageview at VkRenderingFragmentShadingRateAttachmentInfoKHR.
};
struct CaseDef
AttachmentUsage attachmentUsage;
bool shaderWritesRate;
bool geometryShader;
+ bool meshShader;
bool useDynamicState;
bool useApiSampleMask;
bool useSampleMaskIn;
bool sampleShadingEnable;
bool sampleShadingInput;
bool sampleMaskTest;
+ bool earlyAndLateTest;
+ bool garbageAttachment;
bool useAttachment () const
{
return (attachmentUsage == AttachmentUsage::WITH_ATTACHMENT);
}
+
+ bool useAttachmentWithoutImageView () const
+ {
+ return (attachmentUsage == AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW);
+ }
};
class FSRTestInstance : public TestInstance
protected:
- void beginSecondaryCmdBuffer (VkCommandBuffer cmdBuffer,
- VkFormat cbFormat,
- VkFormat dsFormat,
- VkRenderingFlagsKHR renderingFlags = 0u) const;
void preRenderCommands (VkCommandBuffer cmdBuffer,
ImageWithMemory* cbImage,
ImageWithMemory* dsImage,
deUint32 srFillBpp,
const VkClearValue& clearColor,
const VkClearValue& clearDepthStencil);
- void beginRender (VkCommandBuffer cmdBuffer,
+ void beginLegacyRender (VkCommandBuffer cmdBuffer,
VkRenderPass renderPass,
VkFramebuffer framebuffer,
VkImageView srImageView,
- VkImageLayout srImageLayout,
- const VkExtent2D& srTexelSize,
VkImageView cbImageView,
VkImageView dsImageView,
- bool imagelessFB,
- const VkClearValue& clearColor,
- const VkClearValue& clearDepthStencil,
- VkRenderingFlagsKHR renderingFlags = 0u) const;
+ bool imagelessFB) const;
void drawCommands (VkCommandBuffer cmdBuffer,
std::vector<GraphicsPipelineWrapper>& pipelines,
const std::vector<VkViewport>& viewports,
const VkPipelineDepthStencilStateCreateInfo* depthStencilState,
const VkPipelineMultisampleStateCreateInfo* multisampleState,
VkPipelineFragmentShadingRateStateCreateInfoKHR* shadingRateState,
- VkPipelineRenderingCreateInfoKHR* dynamicRendering,
+ PipelineRenderingCreateInfoWrapper dynamicRenderingState,
const VkShaderModule vertShader,
const VkShaderModule geomShader,
+ const VkShaderModule meshShader,
const VkShaderModule fragShader,
- VkDescriptorSet descriptorSet,
- VkBuffer vertexBuffer);
- void endRender (VkCommandBuffer cmdBuffer) const;
+ const std::vector<VkDescriptorSet>& descriptorSet,
+ VkBuffer vertexBuffer,
+ const uint32_t pushConstantSize);
+#ifndef CTS_USES_VULKANSC
+ void beginSecondaryCmdBuffer (VkCommandBuffer cmdBuffer,
+ VkFormat cbFormat,
+ VkFormat dsFormat,
+ VkRenderingFlagsKHR renderingFlags = 0u) const;
+ void beginDynamicRender (VkCommandBuffer cmdBuffer,
+ VkImageView srImageView,
+ VkImageLayout srImageLayout,
+ const VkExtent2D& srTexelSize,
+ VkImageView cbImageView,
+ VkImageView dsImageView,
+ const VkClearValue& clearColor,
+ const VkClearValue& clearDepthStencil,
+ VkRenderingFlagsKHR renderingFlags = 0u) const;
+#endif // CTS_USES_VULKANSC
deInt32 PrimIDToPrimitiveShadingRate (deInt32 primID);
deInt32 PrimIDToPipelineShadingRate (deInt32 primID);
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+static VkImageUsageFlags dsUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
+ VK_IMAGE_USAGE_SAMPLED_BIT |
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+
+
void FSRTestCase::checkSupport(Context& context) const
{
context.requireDeviceFunctionality("VK_KHR_fragment_shading_rate");
- checkPipelineLibraryRequirements(context.getInstanceInterface(), context.getPhysicalDevice(), m_data.groupParams->pipelineConstructionType);
-
if (m_data.groupParams->useDynamicRendering)
context.requireDeviceFunctionality("VK_KHR_dynamic_rendering");
m_data.combinerOp[1] != VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR)
TCU_THROW(NotSupportedError, "attachmentFragmentShadingRate not supported");
- const auto& vki = context.getInstanceInterface();
- const auto physicalDevice = context.getPhysicalDevice();
+ const auto& vki = context.getInstanceInterface();
+ const auto physDev = context.getPhysicalDevice();
- VkImageFormatProperties imageProperties;
- VkResult result = vki.getPhysicalDeviceImageFormatProperties(physicalDevice, VK_FORMAT_R32G32B32A32_UINT, VK_IMAGE_TYPE_2D,
- VK_IMAGE_TILING_OPTIMAL, cbUsage, 0, &imageProperties);
+ VkImageFormatProperties imageProperties;
+ VkResult result = vki.getPhysicalDeviceImageFormatProperties(physDev, VK_FORMAT_R32G32B32A32_UINT, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, cbUsage, 0, &imageProperties);
if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
TCU_THROW(NotSupportedError, "VK_FORMAT_R32G32B32A32_UINT not supported");
+ if (m_data.geometryShader)
+ context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER);
+
if (!(imageProperties.sampleCounts & m_data.samples))
TCU_THROW(NotSupportedError, "color buffer sample count not supported");
if (m_data.sampleMaskTest && !context.getFragmentShadingRateProperties().fragmentShadingRateWithSampleMask)
TCU_THROW(NotSupportedError, "fragmentShadingRateWithSampleMask not supported");
- checkPipelineLibraryRequirements(vki, physicalDevice, m_data.groupParams->pipelineConstructionType);
+#ifndef CTS_USES_VULKANSC
+ if (m_data.meshShader)
+ {
+ context.requireDeviceFunctionality("VK_EXT_mesh_shader");
+ const auto& meshFeatures = context.getMeshShaderFeaturesEXT();
+
+ if (m_data.shaderWritesRate && !meshFeatures.primitiveFragmentShadingRateMeshShader)
+ TCU_THROW(NotSupportedError, "primitiveFragmentShadingRateMeshShader not supported");
+
+ if (m_data.multiView && !meshFeatures.multiviewMeshShader)
+ TCU_THROW(NotSupportedError, "multiviewMeshShader not supported");
+ }
+
+ checkPipelineLibraryRequirements(vki, physDev, m_data.groupParams->pipelineConstructionType);
+
+ if (m_data.earlyAndLateTest)
+ {
+ context.requireDeviceFunctionality("VK_AMD_shader_early_and_late_fragment_tests");
+ if (context.getShaderEarlyAndLateFragmentTestsFeaturesAMD().shaderEarlyAndLateFragmentTests == VK_FALSE)
+ TCU_THROW(NotSupportedError, "shaderEarlyAndLateFragmentTests is not supported");
+ }
+#endif
}
// Error codes writted by the fragment shader
void FSRTestCase::initPrograms (SourceCollections& programCollection) const
{
- std::stringstream vss;
+ if (!m_data.meshShader)
+ {
+ std::stringstream vss;
- vss <<
- "#version 450 core\n"
- "#extension GL_EXT_fragment_shading_rate : enable\n"
- "#extension GL_ARB_shader_viewport_layer_array : enable\n"
- "layout(push_constant) uniform PC {\n"
- " int shadingRate;\n"
- "} pc;\n"
- "layout(location = 0) in vec2 pos;\n"
- "layout(location = 0) out int instanceIndex;\n"
- "layout(location = 1) out int readbackok;\n"
- "layout(location = 2) out float zero;\n"
- "out gl_PerVertex\n"
- "{\n"
- " vec4 gl_Position;\n"
- "};\n"
- "void main()\n"
- "{\n"
- " gl_Position = vec4(pos, 0, 1);\n"
- " instanceIndex = gl_InstanceIndex;\n"
- " readbackok = 1;\n"
- " zero = 0;\n";
+ vss <<
+ "#version 450 core\n"
+ "#extension GL_EXT_fragment_shading_rate : enable\n"
+ "#extension GL_ARB_shader_viewport_layer_array : enable\n"
+ "layout(push_constant) uniform PC {\n"
+ " int shadingRate;\n"
+ "} pc;\n"
+ "layout(location = 0) in vec2 pos;\n"
+ "layout(location = 0) out int instanceIndex;\n"
+ "layout(location = 1) out int readbackok;\n"
+ "layout(location = 2) out float zero;\n"
+ "out gl_PerVertex\n"
+ "{\n"
+ " vec4 gl_Position;\n"
+ "};\n"
+ "void main()\n"
+ "{\n"
+ " gl_Position = vec4(pos, 0, 1);\n"
+ " instanceIndex = gl_InstanceIndex;\n"
+ " readbackok = 1;\n"
+ " zero = 0;\n";
- if (m_data.shaderWritesRate)
- {
- vss << " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n";
+ if (m_data.shaderWritesRate)
+ {
+ vss << " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n";
+
+ // Verify that we can read from the output variable
+ vss << " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
+
+ if (!m_data.geometryShader)
+ {
+ if (m_data.multiViewport)
+ vss << " gl_ViewportIndex = instanceIndex & 1;\n";
+ if (m_data.colorLayered)
+ vss << " gl_Layer = ((instanceIndex & 2) >> 1);\n";
+ }
+ }
- // Verify that we can read from the output variable
- vss << " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
+ vss << "}\n";
- if (!m_data.geometryShader)
+ programCollection.glslSources.add("vert") << glu::VertexSource(vss.str());
+
+ if (m_data.geometryShader)
{
- if (m_data.multiViewport)
- vss << " gl_ViewportIndex = instanceIndex & 1;\n";
- if (m_data.colorLayered)
- vss << " gl_Layer = (instanceIndex & 2) >> 1;\n";
+ std::string writeShadingRate = "";
+ if (m_data.shaderWritesRate)
+ {
+ writeShadingRate =
+ " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n"
+ " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
+
+ if (m_data.multiViewport)
+ writeShadingRate += " gl_ViewportIndex = inInstanceIndex[0] & 1;\n";
+
+ if (m_data.colorLayered)
+ writeShadingRate += " gl_Layer = (inInstanceIndex[0] & 2) >> 1;\n";
+ }
+
+ std::stringstream gss;
+ gss <<
+ "#version 450 core\n"
+ "#extension GL_EXT_fragment_shading_rate : enable\n"
+ "\n"
+ "layout(push_constant) uniform PC {\n"
+ " int shadingRate;\n"
+ "} pc;\n"
+ "\n"
+ "in gl_PerVertex\n"
+ "{\n"
+ " vec4 gl_Position;\n"
+ "} gl_in[3];\n"
+ "\n"
+ "layout(location = 0) in int inInstanceIndex[];\n"
+ "layout(location = 0) out int outInstanceIndex;\n"
+ "layout(location = 1) out int readbackok;\n"
+ "layout(location = 2) out float zero;\n"
+ "layout(triangles) in;\n"
+ "layout(triangle_strip, max_vertices=3) out;\n"
+ "\n"
+ "out gl_PerVertex {\n"
+ " vec4 gl_Position;\n"
+ "};\n"
+ "\n"
+ "void main(void)\n"
+ "{\n"
+ " gl_Position = gl_in[0].gl_Position;\n"
+ " outInstanceIndex = inInstanceIndex[0];\n"
+ " readbackok = 1;\n"
+ " zero = 0;\n"
+ << writeShadingRate <<
+ " EmitVertex();"
+ "\n"
+ " gl_Position = gl_in[1].gl_Position;\n"
+ " outInstanceIndex = inInstanceIndex[1];\n"
+ " readbackok = 1;\n"
+ " zero = 0;\n"
+ << writeShadingRate <<
+ " EmitVertex();"
+ "\n"
+ " gl_Position = gl_in[2].gl_Position;\n"
+ " outInstanceIndex = inInstanceIndex[2];\n"
+ " readbackok = 1;\n"
+ " zero = 0;\n"
+ << writeShadingRate <<
+ " EmitVertex();"
+ "}\n";
+
+ programCollection.glslSources.add("geom") << glu::GeometrySource(gss.str());
}
}
+ else
+ {
+ std::stringstream mss;
- vss << "}\n";
+ mss <<
+ "#version 450 core\n"
+ "#extension GL_EXT_mesh_shader : enable\n"
+ "layout(local_size_x=3) in;\n"
+ "layout(triangles) out;\n"
+ "layout(max_vertices=3, max_primitives=1) out;\n"
+ "layout(push_constant, std430) uniform PC {\n"
+ " int shadingRate;\n"
+ " uint instanceIndex;\n"
+ "} pc;\n"
+ "layout(set=1, binding=0, std430) readonly buffer PosBuffer {\n"
+ " vec2 vertexPositions[];\n"
+ "} pb;\n"
+ "layout(location = 0) flat out int instanceIndex[];\n"
+ "layout(location = 1) flat out int readbackok[];\n"
+ "layout(location = 2) out float zero[];\n";
+
+ if (m_data.shaderWritesRate)
+ {
+ mss <<
+ "perprimitiveEXT out gl_MeshPerPrimitiveEXT {\n"
+ << (m_data.colorLayered ? " int gl_Layer;\n" : "")
+ << (m_data.multiViewport ? " int gl_ViewportIndex;\n" : "") <<
+ " int gl_PrimitiveShadingRateEXT;\n"
+ "} gl_MeshPrimitivesEXT[];\n";
+ }
- programCollection.glslSources.add("vert") << glu::VertexSource(vss.str());
+ mss <<
+ "void main()\n"
+ "{\n"
+ " SetMeshOutputsEXT(3u, 1u);\n"
+ " const uint vertexIdx = (pc.instanceIndex * 3u + gl_LocalInvocationIndex);\n"
+ " gl_MeshVerticesEXT[gl_LocalInvocationIndex].gl_Position = vec4(pb.vertexPositions[vertexIdx], 0, 1);\n"
+ " if (gl_LocalInvocationIndex == 0) {\n"
+ " gl_PrimitiveTriangleIndicesEXT[0] = uvec3(0, 1, 2);\n"
+ " }\n"
+ " instanceIndex[gl_LocalInvocationIndex] = int(pc.instanceIndex);\n"
+ " readbackok[gl_LocalInvocationIndex] = 1;\n"
+ " zero[gl_LocalInvocationIndex] = 0;\n";
- if (m_data.geometryShader)
- {
- std::string writeShadingRate = "";
if (m_data.shaderWritesRate)
{
- writeShadingRate =
- " gl_PrimitiveShadingRateEXT = pc.shadingRate;\n"
- " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
+ mss << " gl_MeshPrimitivesEXT[0].gl_PrimitiveShadingRateEXT = pc.shadingRate;\n";
- if (m_data.multiViewport)
- writeShadingRate += " gl_ViewportIndex = inInstanceIndex[0] & 1;\n";
+ // gl_MeshPerPrimitiveEXT is write-only in mesh shaders, so we cannot verify the readback operation.
+ //mss << " if (gl_PrimitiveShadingRateEXT != pc.shadingRate) readbackok = 0;\n";
+ if (m_data.multiViewport)
+ mss << " gl_MeshPrimitivesEXT[0].gl_ViewportIndex = int(pc.instanceIndex & 1);\n";
if (m_data.colorLayered)
- writeShadingRate += " gl_Layer = (inInstanceIndex[0] & 2) >> 1;\n";
+ mss << " gl_MeshPrimitivesEXT[0].gl_Layer = int((pc.instanceIndex & 2) >> 1);\n";
}
- std::stringstream gss;
- gss <<
- "#version 450 core\n"
- "#extension GL_EXT_fragment_shading_rate : enable\n"
- "\n"
- "layout(push_constant) uniform PC {\n"
- " int shadingRate;\n"
- "} pc;\n"
- "\n"
- "in gl_PerVertex\n"
- "{\n"
- " vec4 gl_Position;\n"
- "} gl_in[3];\n"
- "\n"
- "layout(location = 0) in int inInstanceIndex[];\n"
- "layout(location = 0) out int outInstanceIndex;\n"
- "layout(location = 1) out int readbackok;\n"
- "layout(location = 2) out float zero;\n"
- "layout(triangles) in;\n"
- "layout(triangle_strip, max_vertices=3) out;\n"
- "\n"
- "out gl_PerVertex {\n"
- " vec4 gl_Position;\n"
- "};\n"
- "\n"
- "void main(void)\n"
- "{\n"
- " gl_Position = gl_in[0].gl_Position;\n"
- " outInstanceIndex = inInstanceIndex[0];\n"
- " readbackok = 1;\n"
- " zero = 0;\n"
- << writeShadingRate <<
- " EmitVertex();"
- "\n"
- " gl_Position = gl_in[1].gl_Position;\n"
- " outInstanceIndex = inInstanceIndex[1];\n"
- " readbackok = 1;\n"
- " zero = 0;\n"
- << writeShadingRate <<
- " EmitVertex();"
- "\n"
- " gl_Position = gl_in[2].gl_Position;\n"
- " outInstanceIndex = inInstanceIndex[2];\n"
- " readbackok = 1;\n"
- " zero = 0;\n"
- << writeShadingRate <<
- " EmitVertex();"
- "}\n";
-
- programCollection.glslSources.add("geom") << glu::GeometrySource(gss.str());
+ mss << "}\n";
+
+ const ShaderBuildOptions buildOptions (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);
+ programCollection.glslSources.add("mesh") << glu::MeshSource(mss.str()) << buildOptions;
}
std::stringstream fss;
"#version 450 core\n"
"#extension GL_EXT_fragment_shading_rate : enable\n"
"#extension GL_ARB_shader_stencil_export : enable\n"
- "#extension GL_ARB_fragment_shader_interlock : enable\n"
- "layout(location = 0) out uvec4 col0;\n"
+ "#extension GL_ARB_fragment_shader_interlock : enable\n";
+
+ if (m_data.earlyAndLateTest)
+ fss << "#extension GL_AMD_shader_early_and_late_fragment_tests : enable\n";
+
+ fss << "layout(location = 0) out uvec4 col0;\n"
"layout(set = 0, binding = 0) buffer Block { uint counter; } buf;\n"
"layout(set = 0, binding = 3) uniform usampler2D tex;\n"
"layout(location = 0) flat in int instanceIndex;\n"
"layout(location = 1) flat in int readbackok;\n"
"layout(location = 2) " << (m_data.sampleShadingInput ? "sample " : "") << "in float zero;\n";
+ if (m_data.earlyAndLateTest)
+ fss << "layout(early_and_late_fragment_tests_amd) in;\n";
+
+ if (m_data.fragDepth && m_data.earlyAndLateTest)
+ fss << "layout(depth_less) out float gl_FragDepth;\n";
+
+ if (m_data.fragStencil && m_data.earlyAndLateTest)
+ fss << "layout(stencil_ref_less_front_amd) out int gl_FragStencilRefARB;\n";
+
if (m_data.interlock)
fss << "layout(pixel_interlock_ordered) in;\n";
const VkDevice device = m_context.getDevice();
tcu::TestLog& log = m_context.getTestContext().getLog();
Allocator& allocator = m_context.getDefaultAllocator();
- VkFlags allShaderStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
- VkFlags allPipelineStages = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
- VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+ VkFlags allShaderStages = VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
+ VkFlags allPipelineStages = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
const VkFormat cbFormat = VK_FORMAT_R32G32B32A32_UINT;
VkFormat dsFormat = VK_FORMAT_UNDEFINED;
+ const auto vertBufferUsage = (m_data.meshShader ? VK_BUFFER_USAGE_STORAGE_BUFFER_BIT : VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
- if (m_data.geometryShader)
+ if (m_data.meshShader)
{
- allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
- allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+#ifndef CTS_USES_VULKANSC
+ allShaderStages |= VK_SHADER_STAGE_MESH_BIT_EXT;
+ allPipelineStages |= VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
+#else
+ DE_ASSERT(false);
+#endif // CTS_USES_VULKANSC
+ }
+ else
+ {
+ allShaderStages |= VK_SHADER_STAGE_VERTEX_BIT;
+ allPipelineStages |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
+
+ if (m_data.geometryShader)
+ {
+ allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
+ allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
+ }
}
if (m_data.useDepthStencil)
de::MovePtr<BufferWithMemory> vertexBuffer;
vertexBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
- vk, device, allocator, makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
+ vk, device, allocator, makeBufferCreateInfo(vertexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | vertBufferUsage), MemoryRequirement::HostVisible | MemoryRequirement::Coherent));
float *vbuf = (float *)vertexBuffer->getAllocation().getHostPtr();
for (deInt32 i = 0; i < (deInt32)(vertexBufferSize / sizeof(float)); ++i)
de::MovePtr<ImageWithMemory> dsImage;
Move<VkImageView> dsImageView, dImageView, sImageView;
- VkImageUsageFlags dsUsage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
- VK_IMAGE_USAGE_SAMPLED_BIT |
- VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
- VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+
if (m_data.useDepthStencil)
{
const VkImageCreateInfo imageCreateInfo =
Move<VkSampler> sampler = createSampler(vk, device, &samplerInfo);
- Move<vk::VkDescriptorSetLayout> descriptorSetLayout;
- VkDescriptorSetLayoutCreateFlags layoutCreateFlags = 0;
+ std::vector<Move<vk::VkDescriptorSetLayout>> descriptorSetLayouts;
+ const VkDescriptorSetLayoutCreateFlags layoutCreateFlags = 0;
const VkDescriptorSetLayoutBinding bindings[] =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // sType
DE_NULL, // pNext
layoutCreateFlags, // flags
- sizeof(bindings)/sizeof(bindings[0]), // bindingCount
+ static_cast<uint32_t>(de::arrayLength(bindings)), // bindingCount
&bindings[0] // pBindings
};
- descriptorSetLayout = vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo);
+ descriptorSetLayouts.push_back(vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo));
+
+ // Mesh shaders use set 1 binding 0 as the vertex buffer.
+ if (m_data.meshShader)
+ {
+#ifndef CTS_USES_VULKANSC
+ const VkDescriptorSetLayoutBinding extraBinding =
+ {
+ 0u, // binding
+ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
+ 1u, // descriptorCount
+ VK_SHADER_STAGE_MESH_BIT_EXT, // stageFlags
+ DE_NULL, // pImmutableSamplers
+ };
+
+ const VkDescriptorSetLayoutCreateInfo extraSetLayoutCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // sType
+ DE_NULL, // pNext
+ layoutCreateFlags, // flags
+ 1u, // bindingCount
+ &extraBinding, // pBindings
+ };
+
+ descriptorSetLayouts.push_back(vk::createDescriptorSetLayout(vk, device, &extraSetLayoutCreateInfo));
+#else
+ DE_ASSERT(false);
+#endif // CTS_USES_VULKANSC
+ }
+ const uint32_t numConstants = (m_data.meshShader ? 2u : 1u);
+ const uint32_t pushConstantSize = (static_cast<uint32_t>(sizeof(deInt32)) * numConstants);
const VkPushConstantRange pushConstantRange =
{
- allShaderStages, // VkShaderStageFlags stageFlags;
- 0u, // deUint32 offset;
- sizeof(deInt32) // deUint32 size;
+ allShaderStages, // VkShaderStageFlags stageFlags;
+ 0u, // deUint32 offset;
+ pushConstantSize, // deUint32 size;
};
+ std::vector<VkDescriptorSetLayout> descriptorSetLayoutsRaw;
+ descriptorSetLayoutsRaw.reserve(descriptorSetLayouts.size());
+
+ std::transform(begin(descriptorSetLayouts), end(descriptorSetLayouts), std::back_inserter(descriptorSetLayoutsRaw),
+ [](const Move<VkDescriptorSetLayout>& elem) { return elem.get(); });
+
const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
DE_NULL, // pNext
(VkPipelineLayoutCreateFlags)0,
- 1, // setLayoutCount
- &descriptorSetLayout.get(), // pSetLayouts
+ static_cast<uint32_t>(descriptorSetLayoutsRaw.size()), // setLayoutCount
+ de::dataOrNull(descriptorSetLayoutsRaw), // pSetLayouts
1u, // pushConstantRangeCount
&pushConstantRange, // pPushConstantRanges
};
VkFormat srFormat = srFillFormats[formatIdx];
deUint32 srFillBpp = tcu::getPixelSize(mapVkFormat(srFormat));
- VkImageLayout srLayout = modeIdx == ATTACHMENT_MODE_LAYOUT_OPTIMAL ? VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR : VK_IMAGE_LAYOUT_GENERAL;
- VkImageViewType srViewType = modeIdx == ATTACHMENT_MODE_2DARRAY ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
- VkImageTiling srTiling = (modeIdx == ATTACHMENT_MODE_TILING_LINEAR) ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
+ VkImageLayout srLayout = modeIdx == ATTACHMENT_MODE_LAYOUT_OPTIMAL ? VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR : VK_IMAGE_LAYOUT_GENERAL;
+ VkImageViewType srViewType = (modeIdx == ATTACHMENT_MODE_2DARRAY || numSRLayers > 1u) ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
+ VkImageTiling srTiling = (modeIdx == ATTACHMENT_MODE_TILING_LINEAR) ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
VkFormatProperties srFormatProperties;
m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), srFormat, &srFormatProperties);
continue;
}
- Move<vk::VkDescriptorPool> descriptorPool;
- Move<vk::VkDescriptorSet> descriptorSet;
- VkDescriptorPoolCreateFlags poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
+ Move<vk::VkDescriptorPool> descriptorPool;
+ std::vector<Move<vk::VkDescriptorSet>> descriptorSets;
+ VkDescriptorPoolCreateFlags poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
vk::DescriptorPoolBuilder poolBuilder;
for (deInt32 i = 0; i < (deInt32)(sizeof(bindings)/sizeof(bindings[0])); ++i)
poolBuilder.addType(bindings[i].descriptorType, bindings[i].descriptorCount);
+ if (m_data.meshShader)
+ poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
- descriptorPool = poolBuilder.build(vk, device, poolCreateFlags, 1u);
- descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
+ descriptorPool = poolBuilder.build(vk, device, poolCreateFlags, static_cast<uint32_t>(descriptorSetLayouts.size()));
+ for (const auto& setLayout : descriptorSetLayouts)
+ descriptorSets.push_back(makeDescriptorSet(vk, device, *descriptorPool, *setLayout));
+
+ const auto mainDescriptorSet = descriptorSets.front().get();
de::MovePtr<ImageWithMemory> srImage;
Move<VkImageView> srImageView;
{
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
DE_NULL, // pNext
- *descriptorSet, // dstSet
+ descriptorSets.front().get(), // dstSet
(deUint32)0, // dstBinding
0, // dstArrayElement
1u, // descriptorCount
vk.updateDescriptorSets(device, 1, &w, 0, NULL);
}
+ // Update vertex buffer descriptor.
+ if (m_data.meshShader)
+ {
+ const auto extraBufferInfo = makeDescriptorBufferInfo(vertexBuffer->get(), 0ull, vertexBufferSize);
+ const VkWriteDescriptorSet extraWrite =
+ {
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // sType
+ DE_NULL, // pNext
+ descriptorSets.back().get(), // dstSet
+ (deUint32)0, // dstBinding
+ 0, // dstArrayElement
+ 1u, // descriptorCount
+ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // descriptorType
+ nullptr, // pImageInfo
+ &extraBufferInfo, // pBufferInfo
+ DE_NULL, // pTexelBufferView
+ };
+
+ vk.updateDescriptorSets(device, 1u, &extraWrite, 0u, nullptr);
+ }
+
Move<VkRenderPass> renderPass;
Move<VkFramebuffer> framebuffer;
VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkAttachmentDescriptionFlags)0u, // VkAttachmentDescriptionFlags flags;
- dsFormat, // VkFormat format;
+ dsFormat, // VkFormat format;
m_data.samples, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
srWidth, // deUint32 width;
srHeight, // deUint32 height;
numSRLayers, // deUint32 layerCount;
- 1u, // deUint32 viewFormatCount;
+ srViewType == VK_IMAGE_VIEW_TYPE_2D ? 1 : numSRLayers, // deUint32 viewFormatCount;
&srFormat // const VkFormat* pViewFormats;
}
);
// Split the viewport into left and right halves
int x0 = 0, x1 = m_data.framebufferDim.width/2, x2 = m_data.framebufferDim.width;
- viewports.push_back(makeViewport((float)x0, 0, (float)(x1-x0), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
- scissors.push_back(makeRect2D(x0, 0, x1-x0, m_data.framebufferDim.height));
+ viewports.push_back(makeViewport((float)x0, 0, std::max((float)(x1 - x0), 1.0f), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
+ scissors.push_back(makeRect2D(x0, 0, x1 - x0, m_data.framebufferDim.height));
- viewports.push_back(makeViewport((float)x1, 0, (float)(x2-x1), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
- scissors.push_back(makeRect2D(x1, 0, x2-x1, m_data.framebufferDim.height));
+ viewports.push_back(makeViewport((float)x1, 0, std::max((float)(x2 - x1), 1.0f), (float)m_data.framebufferDim.height, 0.0f, 1.0f));
+ scissors.push_back(makeRect2D(x1, 0, x2 - x1, m_data.framebufferDim.height));
}
else
{
scissors.push_back(makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height));
}
- Move<VkShaderModule> fragShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0);
- Move<VkShaderModule> vertShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0);
+ const auto& binaries = m_context.getBinaryCollection();
+ Move<VkShaderModule> fragShader = createShaderModule(vk, device, binaries.get("frag"), 0);
+ Move<VkShaderModule> vertShader;
Move<VkShaderModule> geomShader;
- if (m_data.geometryShader)
- geomShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("geom"), 0);
+ Move<VkShaderModule> meshShader;
+
+ if (m_data.meshShader)
+ {
+ meshShader = createShaderModule(vk, device, binaries.get("mesh"), 0);
+ }
+ else
+ {
+ vertShader = createShaderModule(vk, device, binaries.get("vert"), 0);
+ if (m_data.geometryShader)
+ geomShader = createShaderModule(vk, device, binaries.get("geom"), 0);
+ }
const deUint32 fragSizeWH = m_data.sampleMaskTest ? 2 : 0;
+ PipelineRenderingCreateInfoWrapper renderingCreateInfoWrapper;
#ifndef CTS_USES_VULKANSC
VkPipelineRenderingCreateInfoKHR renderingCreateInfo
{
dsFormat,
dsFormat
};
+ renderingCreateInfoWrapper.ptr = m_data.groupParams->useDynamicRendering ? &renderingCreateInfo : DE_NULL;
#endif // CTS_USES_VULKANSC
VkPipelineFragmentShadingRateStateCreateInfoKHR shadingRateStateCreateInfo
{
VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, // VkStructureType sType;
-#ifndef CTS_USES_VULKANSC
- m_data.groupParams->useDynamicRendering ? &renderingCreateInfo : DE_NULL, // const void* pNext;
-#else
- DE_NULL, // const void* pNext;
-#endif // CTS_USES_VULKANSC
+ renderingCreateInfoWrapper.ptr, // const void* pNext;
{ fragSizeWH, fragSizeWH }, // VkExtent2D fragmentSize;
{ m_data.combinerOp[0], m_data.combinerOp[1] }, // VkFragmentShadingRateCombinerOpKHR combinerOps[2];
};
m_data.useDynamicState ? 1u : 0u, // uint32_t dynamicStateCount;
&dynamicState, // const VkDynamicState* pDynamicStates;
};
- vk::VkPipelineRenderingCreateInfoKHR* pDynamicRendering = (m_data.groupParams->useDynamicRendering ? &renderingCreateInfo : DE_NULL);
// Enable depth/stencil writes, always passing
- VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
+ VkPipelineDepthStencilStateCreateInfo depthStencilStateParams
{
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
Move<VkCommandBuffer> secCmdBuffer;
VkClearValue clearColor = makeClearValueColorU32(0, 0, 0, 0);
VkClearValue clearDepthStencil = makeClearValueDepthStencil(0.0, 0);
- const VkExtent2D srTexelSize { srTexelWidth, srTexelHeight };
std::vector<GraphicsPipelineWrapper> pipelines;
pipelines.reserve(m_data.useDynamicState ? 1u : NUM_TRIANGLES);
+ std::vector<VkDescriptorSet> descriptorSetsRaw;
+
+ descriptorSetsRaw.reserve(descriptorSets.size());
+
+ std::transform(begin(descriptorSets), end(descriptorSets), std::back_inserter(descriptorSetsRaw),
+ [](const Move<VkDescriptorSet>& elem) { return elem.get(); });
+
+#ifndef CTS_USES_VULKANSC
+ const VkExtent2D srTexelSize { srTexelWidth, srTexelHeight };
if (m_data.groupParams->useSecondaryCmdBuffer)
{
secCmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
if (m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
{
beginSecondaryCmdBuffer(*secCmdBuffer, cbFormat, dsFormat, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT);
- beginRender(*secCmdBuffer, *renderPass, *framebuffer, *srImageView, srLayout, srTexelSize,
- *cbImageView, *dsImageView, imagelessFB, clearColor, clearDepthStencil);
+ beginDynamicRender(*secCmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView,
+ clearColor, clearDepthStencil);
}
else
beginSecondaryCmdBuffer(*secCmdBuffer, cbFormat, dsFormat);
drawCommands(*secCmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
&vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
&depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
- pDynamicRendering, *vertShader, *geomShader, *fragShader, *descriptorSet, **vertexBuffer);
+ renderingCreateInfoWrapper, *vertShader, *geomShader, *meshShader, *fragShader, descriptorSetsRaw, **vertexBuffer, pushConstantSize);
if (m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
- endRender(*secCmdBuffer);
+ endRendering(vk, *secCmdBuffer);
endCommandBuffer(vk, *secCmdBuffer);
preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
if (!m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
- beginRender(*cmdBuffer, *renderPass, *framebuffer, *srImageView, srLayout, srTexelSize,
- *cbImageView, *dsImageView, imagelessFB, clearColor, clearDepthStencil, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
+ beginDynamicRender(*cmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView,
+ clearColor, clearDepthStencil, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR);
vk.cmdExecuteCommands(*cmdBuffer, 1u, &*secCmdBuffer);
if (!m_data.groupParams->secondaryCmdBufferCompletelyContainsDynamicRenderpass)
- endRender(*cmdBuffer);
+ endRendering(vk, *cmdBuffer);
}
- else
+ else if (m_data.groupParams->useDynamicRendering)
+ {
+ beginCommandBuffer(vk, *cmdBuffer);
+ preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
+ srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
+ beginDynamicRender(*cmdBuffer, *srImageView, srLayout, srTexelSize, *cbImageView, *dsImageView, clearColor, clearDepthStencil);
+ drawCommands(*cmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
+ &vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
+ &depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
+ renderingCreateInfoWrapper, *vertShader, *geomShader, *meshShader, *fragShader, descriptorSetsRaw, **vertexBuffer, pushConstantSize);
+ endRendering(vk, *cmdBuffer);
+ }
+#endif // CTS_USES_VULKANSC
+
+ if (!m_data.groupParams->useDynamicRendering)
{
beginCommandBuffer(vk, *cmdBuffer);
preRenderCommands(*cmdBuffer, cbImage.get(), dsImage.get(), derivImage.get(), derivNumLevels, srImage.get(), srLayout,
srFillBuffer.get(), numSRLayers, srWidth, srHeight, srFillBpp, clearColor, clearDepthStencil);
- beginRender(*cmdBuffer, *renderPass, *framebuffer, *srImageView, srLayout, srTexelSize,
- *cbImageView, *dsImageView, imagelessFB, clearColor, clearDepthStencil);
+ beginLegacyRender(*cmdBuffer, *renderPass, *framebuffer, *srImageView, *cbImageView, *dsImageView, imagelessFB);
drawCommands(*cmdBuffer, pipelines, viewports, scissors, *pipelineLayout, *renderPass,
&vertexInputStateCreateInfo, &dynamicStateCreateInfo, &rasterizationStateCreateInfo,
&depthStencilStateParams, &multisampleStateCreateInfo, &shadingRateStateCreateInfo,
- pDynamicRendering, *vertShader, *geomShader, *fragShader, *descriptorSet, **vertexBuffer);
- endRender(*cmdBuffer);
+ renderingCreateInfoWrapper, *vertShader, *geomShader, *meshShader, *fragShader, descriptorSetsRaw, **vertexBuffer, pushConstantSize);
+ endRenderPass(vk, *cmdBuffer);
}
VkMemoryBarrier memBarrier
};
vk.cmdPipelineBarrier(*cmdBuffer, allPipelineStages, allPipelineStages, 0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
- vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1, &*descriptorSet, 0u, DE_NULL);
+ vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1, &mainDescriptorSet, 0u, DE_NULL);
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *computePipeline);
// Copy color/depth/stencil buffers to buffer memory
return tcu::TestStatus(res, qpGetTestResultName(res));
}
+#ifndef CTS_USES_VULKANSC
void FSRTestInstance::beginSecondaryCmdBuffer(VkCommandBuffer cmdBuffer, VkFormat cbFormat, VkFormat dsFormat, VkRenderingFlagsKHR renderingFlags) const
{
VkCommandBufferInheritanceRenderingInfoKHR inheritanceRenderingInfo
VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &commandBufBeginParams));
}
+void FSRTestInstance::beginDynamicRender(VkCommandBuffer cmdBuffer, VkImageView srImageView, VkImageLayout srImageLayout,
+ const VkExtent2D& srTexelSize, VkImageView cbImageView, VkImageView dsImageView,
+ const VkClearValue& clearColor, const VkClearValue& clearDepthStencil,
+ VkRenderingFlagsKHR renderingFlags) const
+{
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ VkRect2D renderArea = makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height);
+
+ VkRenderingFragmentShadingRateAttachmentInfoKHR shadingRateAttachmentInfo
+ {
+ VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ m_data.useAttachment() ? srImageView : DE_NULL, // VkImageView imageView;
+ srImageLayout, // VkImageLayout imageLayout;
+ srTexelSize // VkExtent2D shadingRateAttachmentTexelSize;
+ };
+
+ VkRenderingAttachmentInfoKHR colorAttachment
+ {
+ vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ cbImageView, // VkImageView imageView;
+ VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout imageLayout;
+ VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
+ DE_NULL, // VkImageView resolveImageView;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
+ VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
+ clearColor // VkClearValue clearValue;
+ };
+
+ std::vector<VkRenderingAttachmentInfoKHR> depthStencilAttachments(2,
+ {
+ VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ dsImageView, // VkImageView imageView;
+ VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout imageLayout;
+ VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
+ DE_NULL, // VkImageView resolveImageView;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
+ VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
+ VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
+ clearDepthStencil // VkClearValue clearValue;
+ });
+
+ vk::VkRenderingInfoKHR renderingInfo
+ {
+ vk::VK_STRUCTURE_TYPE_RENDERING_INFO_KHR,
+ m_data.useAttachment() || m_data.useAttachmentWithoutImageView() ? &shadingRateAttachmentInfo : DE_NULL,
+ renderingFlags, // VkRenderingFlagsKHR flags;
+ renderArea, // VkRect2D renderArea;
+ m_data.multiView ? 1 : m_data.numColorLayers, // deUint32 layerCount;
+ m_data.multiView ? 0x3 : 0u, // deUint32 viewMask;
+ 1u, // deUint32 colorAttachmentCount;
+ &colorAttachment, // const VkRenderingAttachmentInfoKHR* pColorAttachments;
+ m_data.useDepthStencil ? &depthStencilAttachments[0] : DE_NULL, // const VkRenderingAttachmentInfoKHR* pDepthAttachment;
+ m_data.useDepthStencil ? &depthStencilAttachments[1] : DE_NULL, // const VkRenderingAttachmentInfoKHR* pStencilAttachment;
+ };
+
+ vk.cmdBeginRendering(cmdBuffer, &renderingInfo);
+}
+#endif // CTS_USES_VULKANSC
+
void FSRTestInstance::preRenderCommands(VkCommandBuffer cmdBuffer, ImageWithMemory* cbImage, ImageWithMemory* dsImage,
ImageWithMemory* derivImage, deUint32 derivNumLevels,
ImageWithMemory* srImage, VkImageLayout srLayout, BufferWithMemory* srFillBuffer,
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
- VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV;
+ VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
if (m_data.geometryShader)
allPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);
}
-void FSRTestInstance::beginRender(VkCommandBuffer cmdBuffer, VkRenderPass renderPass, VkFramebuffer framebuffer,
- VkImageView srImageView, VkImageLayout srImageLayout, const VkExtent2D& srTexelSize,
- VkImageView cbImageView, VkImageView dsImageView, bool imagelessFB,
- const VkClearValue& clearColor, const VkClearValue& clearDepthStencil,
- VkRenderingFlagsKHR renderingFlags) const
+void FSRTestInstance::beginLegacyRender(VkCommandBuffer cmdBuffer, VkRenderPass renderPass, VkFramebuffer framebuffer,
+ VkImageView srImageView, VkImageView cbImageView, VkImageView dsImageView, bool imagelessFB) const
{
const DeviceInterface& vk = m_context.getDeviceInterface();
VkRect2D renderArea = makeRect2D(m_data.framebufferDim.width, m_data.framebufferDim.height);
- if (m_data.groupParams->useDynamicRendering)
- {
- VkRenderingFragmentShadingRateAttachmentInfoKHR shadingRateAttachmentInfo
- {
- VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- srImageView, // VkImageView imageView;
- srImageLayout, // VkImageLayout imageLayout;
- srTexelSize // VkExtent2D shadingRateAttachmentTexelSize;
- };
-
- VkRenderingAttachmentInfoKHR colorAttachment
- {
- vk::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- cbImageView, // VkImageView imageView;
- VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout imageLayout;
- VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
- DE_NULL, // VkImageView resolveImageView;
- VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
- VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
- VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
- clearColor // VkClearValue clearValue;
- };
-
- std::vector<VkRenderingAttachmentInfoKHR> depthStencilAttachments(2,
- {
- VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- dsImageView, // VkImageView imageView;
- VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout imageLayout;
- VK_RESOLVE_MODE_NONE, // VkResolveModeFlagBits resolveMode;
- DE_NULL, // VkImageView resolveImageView;
- VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout resolveImageLayout;
- VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
- VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
- clearDepthStencil // VkClearValue clearValue;
- });
-
- vk::VkRenderingInfoKHR renderingInfo
- {
- vk::VK_STRUCTURE_TYPE_RENDERING_INFO_KHR,
- m_data.useAttachment() ? &shadingRateAttachmentInfo : DE_NULL,
- renderingFlags, // VkRenderingFlagsKHR flags;
- renderArea, // VkRect2D renderArea;
- m_data.multiView ? 1 : m_data.numColorLayers, // deUint32 layerCount;
- m_data.multiView ? 0x3 : 0u, // deUint32 viewMask;
- 1u, // deUint32 colorAttachmentCount;
- &colorAttachment, // const VkRenderingAttachmentInfoKHR* pColorAttachments;
- m_data.useDepthStencil ? &depthStencilAttachments[0] : DE_NULL, // const VkRenderingAttachmentInfoKHR* pDepthAttachment;
- m_data.useDepthStencil ? &depthStencilAttachments[1] : DE_NULL, // const VkRenderingAttachmentInfoKHR* pStencilAttachment;
- };
+ std::vector<VkImageView> attachments = { cbImageView };
+ if (m_data.useAttachment())
+ attachments.push_back(srImageView);
+ if (m_data.useDepthStencil)
+ attachments.push_back(dsImageView);
- vk.cmdBeginRendering(cmdBuffer, &renderingInfo);
- }
- else
+ const VkRenderPassAttachmentBeginInfo renderPassAttachmentBeginInfo
{
- std::vector<VkImageView> attachments = { cbImageView };
- if (m_data.useAttachment())
- attachments.push_back(srImageView);
- if (m_data.useDepthStencil)
- attachments.push_back(dsImageView);
-
- const VkRenderPassAttachmentBeginInfo renderPassAttachmentBeginInfo
- {
- VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (deUint32)attachments.size(), // deUint32 attachmentCount;
- &attachments[0] // const VkImageView* pAttachments;
- };
+ VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (deUint32)attachments.size(), // deUint32 attachmentCount;
+ &attachments[0] // const VkImageView* pAttachments;
+ };
- beginRenderPass(vk, cmdBuffer, renderPass, framebuffer, renderArea,
- 0, DE_NULL, VK_SUBPASS_CONTENTS_INLINE, imagelessFB ? &renderPassAttachmentBeginInfo : DE_NULL);
- }
+ beginRenderPass(vk, cmdBuffer, renderPass, framebuffer, renderArea,
+ 0, DE_NULL, VK_SUBPASS_CONTENTS_INLINE, imagelessFB ? &renderPassAttachmentBeginInfo : DE_NULL);
}
void FSRTestInstance::drawCommands(VkCommandBuffer cmdBuffer,
const VkPipelineDepthStencilStateCreateInfo* depthStencilState,
const VkPipelineMultisampleStateCreateInfo* multisampleState,
VkPipelineFragmentShadingRateStateCreateInfoKHR* shadingRateState,
- VkPipelineRenderingCreateInfoKHR* dynamicRendering,
+ PipelineRenderingCreateInfoWrapper dynamicRenderingState,
const VkShaderModule vertShader,
const VkShaderModule geomShader,
+ const VkShaderModule meshShader,
const VkShaderModule fragShader,
- VkDescriptorSet descriptorSet,
- VkBuffer vertexBuffer)
+ const std::vector<VkDescriptorSet>& descriptorSets,
+ VkBuffer vertexBuffer,
+ const uint32_t pushConstantSize)
{
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice device = m_context.getDevice();
+ const bool useMesh = (meshShader != DE_NULL);
- VkFlags allShaderStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
- if (m_data.geometryShader)
- allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
+#ifdef CTS_USES_VULKANSC
+ if (useMesh)
+ DE_ASSERT(false);
+#endif // CTS_USES_VULKANSC
+
+ VkFlags allShaderStages = VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
+
+ if (useMesh)
+ {
+#ifndef CTS_USES_VULKANSC
+ allShaderStages |= VK_SHADER_STAGE_MESH_BIT_EXT;
+#endif // CTS_USES_VULKANSC
+ }
+ else
+ {
+ allShaderStages |= VK_SHADER_STAGE_VERTEX_BIT;
+ if (m_data.geometryShader)
+ allShaderStages |= VK_SHADER_STAGE_GEOMETRY_BIT;
+ }
VkPipelineCreateFlags pipelineCreateFlags = (VkPipelineCreateFlags)0;
+
+#ifndef CTS_USES_VULKANSC
if (m_data.groupParams->useDynamicRendering)
pipelineCreateFlags |= VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
+#endif // CTS_USES_VULKANSC
- vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, DE_NULL);
+ vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, static_cast<uint32_t>(descriptorSets.size()), de::dataOrNull(descriptorSets), 0, DE_NULL);
+
+ PipelineRenderingCreateInfoWrapper pipelineRenderingCreateInfo = dynamicRenderingState;
+#ifndef CTS_USES_VULKANSC
+ vk::VkPipelineRenderingCreateInfo pipelineRenderingCreateInfoWithGarbage;
+ if (m_data.garbageAttachment)
+ {
+ pipelineRenderingCreateInfoWithGarbage = *dynamicRenderingState.ptr;
+ pipelineRenderingCreateInfoWithGarbage.colorAttachmentCount = 99999u;
+ pipelineRenderingCreateInfoWithGarbage.pColorAttachmentFormats = reinterpret_cast<VkFormat *>(0x11);
+
+ pipelineRenderingCreateInfo = &pipelineRenderingCreateInfoWithGarbage;
+ }
+#endif
// If using dynamic state, create a single graphics pipeline and bind it
if (m_data.useDynamicState)
{
pipelines.emplace_back(vk, device, m_data.groupParams->pipelineConstructionType, pipelineCreateFlags);
- pipelines.back()
+ auto& pipeline = pipelines.back();
+
+ pipeline
.setDefaultColorBlendState()
- .setDynamicState(dynamicState)
- .setupVertexInputStete(vertexInputState)
- .setupPreRasterizationShaderState(viewports,
- scissors,
- pipelineLayout,
- renderPass,
- 0u,
- vertShader,
- rasterizationState,
- DE_NULL,
- DE_NULL,
- geomShader,
- DE_NULL,
- dynamicRendering)
+ .setDynamicState(dynamicState);
+
+ if (useMesh)
+ {
+#ifndef CTS_USES_VULKANSC
+ pipeline
+ .setupPreRasterizationMeshShaderState(viewports,
+ scissors,
+ pipelineLayout,
+ renderPass,
+ 0u,
+ DE_NULL,
+ meshShader,
+ rasterizationState,
+ nullptr,
+ nullptr,
+ shadingRateState,
+ pipelineRenderingCreateInfo);
+#endif // CTS_USES_VULKANSC
+ }
+ else
+ {
+ pipeline
+ .setupVertexInputState(vertexInputState)
+ .setupPreRasterizationShaderState(viewports,
+ scissors,
+ pipelineLayout,
+ renderPass,
+ 0u,
+ vertShader,
+ rasterizationState,
+ DE_NULL,
+ DE_NULL,
+ geomShader,
+ DE_NULL,
+ shadingRateState,
+ pipelineRenderingCreateInfo);
+ }
+
+ pipeline
.setupFragmentShaderState(pipelineLayout,
renderPass,
0u,
fragShader,
depthStencilState,
- multisampleState,
- shadingRateState)
+ multisampleState)
.setupFragmentOutputState(renderPass, 0u, DE_NULL, multisampleState)
.setMonolithicPipelineLayout(pipelineLayout)
.buildPipeline();
- vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.back().getPipeline());
+ vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.getPipeline());
}
+ // Push constant block (must match shaders).
+ struct
+ {
+ int32_t shadingRate;
+ uint32_t instanceIndex;
+ } pushConstantBlock;
+
for (deInt32 i = 0; i < NUM_TRIANGLES; ++i)
{
- // Bind vertex attributes pointing to the next triangle
- VkDeviceSize vertexBufferOffset = i * 3 * 2 * sizeof(float);
- vk.cmdBindVertexBuffers(cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
+ if (!useMesh)
+ {
+ // Bind vertex attributes pointing to the next triangle
+ VkDeviceSize vertexBufferOffset = i * 3 * 2 * sizeof(float);
+ vk.cmdBindVertexBuffers(cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
+ }
- // Put primitive shading rate in a push constant
- deInt32 shadingRatePC = PrimIDToPrimitiveShadingRate(i);
- vk.cmdPushConstants(cmdBuffer, pipelineLayout, allShaderStages, 0, sizeof(shadingRatePC), &shadingRatePC);
+ // Put primitive shading rate and instance index (used in mesh shading cases) in push constants.
+ pushConstantBlock.shadingRate = PrimIDToPrimitiveShadingRate(i);
+ pushConstantBlock.instanceIndex = static_cast<uint32_t>(i);
+ vk.cmdPushConstants(cmdBuffer, pipelineLayout, allShaderStages, 0, pushConstantSize, &pushConstantBlock);
if (m_data.useDynamicState)
{
shadingRateState->fragmentSize = ShadingRateEnumToExtent(PrimIDToPipelineShadingRate(i));
pipelines.emplace_back(vk, device, m_data.groupParams->pipelineConstructionType, pipelineCreateFlags);
- pipelines.back()
+ auto& pipeline = pipelines.back();
+
+ pipeline
.setDefaultColorBlendState()
- .setDynamicState(dynamicState)
- .setupVertexInputStete(vertexInputState)
- .setupPreRasterizationShaderState(viewports,
- scissors,
- pipelineLayout,
- renderPass,
- 0u,
- vertShader,
- rasterizationState,
- DE_NULL,
- DE_NULL,
- geomShader,
- DE_NULL,
- dynamicRendering)
+ .setDynamicState(dynamicState);
+
+ if (useMesh)
+ {
+#ifndef CTS_USES_VULKANSC
+ pipeline
+ .setupPreRasterizationMeshShaderState(viewports,
+ scissors,
+ pipelineLayout,
+ renderPass,
+ 0u,
+ DE_NULL,
+ meshShader,
+ rasterizationState,
+ nullptr,
+ nullptr,
+ shadingRateState,
+ dynamicRenderingState);
+#endif // CTS_USES_VULKANSC
+ }
+ else
+ {
+ pipeline
+ .setupVertexInputState(vertexInputState)
+ .setupPreRasterizationShaderState(viewports,
+ scissors,
+ pipelineLayout,
+ renderPass,
+ 0u,
+ vertShader,
+ rasterizationState,
+ DE_NULL,
+ DE_NULL,
+ geomShader,
+ DE_NULL,
+ shadingRateState,
+ dynamicRenderingState);
+ }
+
+ pipeline
.setupFragmentShaderState(pipelineLayout,
renderPass,
0u,
fragShader,
depthStencilState,
- multisampleState,
- shadingRateState)
+ multisampleState)
+#ifndef CTS_USES_VULKANSC
+ .setRenderingColorAttachmentsInfo(dynamicRenderingState)
+#endif
.setupFragmentOutputState(renderPass, 0u, DE_NULL, multisampleState)
.setMonolithicPipelineLayout(pipelineLayout)
.buildPipeline();
- vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.back().getPipeline());
+ vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.getPipeline());
}
- // Draw one triangle, with "primitive ID" in gl_InstanceIndex
- vk.cmdDraw(cmdBuffer, 3u, 1, 0u, i);
+ if (useMesh)
+ {
+#ifndef CTS_USES_VULKANSC
+ // Create a single workgroup to draw one triangle. The "primitive id" will be in the push constants.
+ vk.cmdDrawMeshTasksEXT(cmdBuffer, 1u, 1u, 1u);
+#endif // CTS_USES_VULKANSC
+ }
+ else
+ {
+ // Draw one triangle, with "primitive ID" in gl_InstanceIndex
+ vk.cmdDraw(cmdBuffer, 3u, 1, 0u, i);
+ }
}
}
-void FSRTestInstance::endRender(VkCommandBuffer cmdBuffer) const
-{
- const DeviceInterface& vk = m_context.getDeviceInterface();
- if (m_data.groupParams->useDynamicRendering)
- endRendering(vk, cmdBuffer);
- else
- endRenderPass(vk, cmdBuffer);
-}
-
} // anonymous
void createBasicTests (tcu::TestContext& testCtx, tcu::TestCaseGroup* parentGroup, SharedGroupParams groupParams)
TestGroupCase groupCases[] =
{
- { 0, "basic", "basic tests" },
- { 1, "apisamplemask", "use pSampleMask" },
- { 2, "samplemaskin", "use gl_SampleMaskIn" },
- { 3, "conservativeunder", "conservative underestimation" },
- { 4, "conservativeover", "conservative overestimation" },
- { 5, "fragdepth", "depth shader output" },
- { 6, "fragstencil", "stencil shader output" },
- { 7, "multiviewport", "multiple viewports and gl_ViewportIndex" },
- { 8, "colorlayered", "multiple layer color, single layer shading rate" },
- { 9, "srlayered", "multiple layer color, multiple layers shading rate" },
- { 10, "multiview", "multiview" },
- { 11, "multiviewsrlayered", "multiview and multilayer shading rate" },
- { 12, "multiviewcorrelation", "multiview with correlation mask" },
- { 13, "interlock", "fragment shader interlock" },
- { 14, "samplelocations", "custom sample locations" },
- { 15, "sampleshadingenable", "enable sample shading in createinfo" },
- { 16, "sampleshadinginput", "enable sample shading by using gl_SampleID" },
+ { 0, "basic", "basic tests" },
+ { 1, "apisamplemask", "use pSampleMask" },
+ { 2, "samplemaskin", "use gl_SampleMaskIn" },
+ { 3, "conservativeunder", "conservative underestimation" },
+ { 4, "conservativeover", "conservative overestimation" },
+ { 5, "fragdepth", "depth shader output" },
+ { 6, "fragstencil", "stencil shader output" },
+ { 7, "multiviewport", "multiple viewports and gl_ViewportIndex" },
+ { 8, "colorlayered", "multiple layer color, single layer shading rate" },
+ { 9, "srlayered", "multiple layer color, multiple layers shading rate" },
+ { 10, "multiview", "multiview" },
+ { 11, "multiviewsrlayered", "multiview and multilayer shading rate" },
+ { 12, "multiviewcorrelation", "multiview with correlation mask" },
+ { 13, "interlock", "fragment shader interlock" },
+ { 14, "samplelocations", "custom sample locations" },
+ { 15, "sampleshadingenable", "enable sample shading in createinfo" },
+ { 16, "sampleshadinginput", "enable sample shading by using gl_SampleID" },
+#ifndef CTS_USES_VULKANSC
+ { 17, "fragdepth_early_late", "depth shader output" },
+ { 18, "fragstencil_early_late", "stencil shader output" },
+#endif
};
TestGroupCase dynCases[] =
TestGroupUsageCase attCases[] =
{
- { AttachmentUsage::NO_ATTACHMENT, "noattachment", "no shading rate attachment" },
- { AttachmentUsage::WITH_ATTACHMENT, "attachment", "has shading rate attachment" },
- { AttachmentUsage::NO_ATTACHMENT_PTR, "noattachmentptr", "no shading rate attachment pointer" },
+ { AttachmentUsage::NO_ATTACHMENT, "noattachment", "no shading rate attachment" },
+ { AttachmentUsage::WITH_ATTACHMENT, "attachment", "has shading rate attachment" },
+ { AttachmentUsage::NO_ATTACHMENT_PTR, "noattachmentptr", "no shading rate attachment pointer" },
+ { AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW, "attachment_noimageview", "has shading rate attachment without imageview" },
};
TestGroupCase shdCases[] =
{ VK_SAMPLE_COUNT_16_BIT, "samples16", "16 raster samples" },
};
- TestGroupCase geomCases[] =
+ TestGroupCase shaderCases[] =
{
- { 0, "vs", "vertex shader only" },
+ { 0, "vs", "vertex shader only" },
{ 1, "gs", "vertex and geometry shader" },
+#ifndef CTS_USES_VULKANSC
+ { 2, "ms", "mesh shader" },
+#endif // CTS_USES_VULKANSC
};
deInt32 seed = 0;
if (groupParams->useDynamicRendering && attCases[attNdx].usage == AttachmentUsage::NO_ATTACHMENT_PTR)
continue;
+ // WITH_ATTACHMENT_WITHOUT_IMAGEVIEW is only for VkRenderingFragmentShadingRateAttachmentInfoKHR.
+ if (!groupParams->useDynamicRendering && attCases[attNdx].usage == AttachmentUsage::WITH_ATTACHMENT_WITHOUT_IMAGEVIEW)
+ continue;
+
de::MovePtr<tcu::TestCaseGroup> attGroup(new tcu::TestCaseGroup(testCtx, attCases[attNdx].name, attCases[attNdx].description));
for (int shdNdx = 0; shdNdx < DE_LENGTH_OF_ARRAY(shdCases); shdNdx++)
{
continue;
de::MovePtr<tcu::TestCaseGroup> sampGroup(new tcu::TestCaseGroup(testCtx, sampCases[sampNdx].name, sampCases[sampNdx].description));
- for (int geomNdx = 0; geomNdx < DE_LENGTH_OF_ARRAY(geomCases); geomNdx++)
+ for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(shaderCases); shaderNdx++)
{
// reduce number of tests for dynamic rendering cases where secondary command buffer is used
- if (groupParams->useSecondaryCmdBuffer && (geomNdx != 0))
+ if (groupParams->useSecondaryCmdBuffer && (shaderNdx != 0))
continue;
bool useApiSampleMask = groupNdx == 1;
bool useSampleMaskIn = groupNdx == 2;
bool consRast = groupNdx == 3 || groupNdx == 4;
- bool fragDepth = groupNdx == 5;
- bool fragStencil = groupNdx == 6;
+ bool fragDepth = groupNdx == 5 || groupNdx == 17;
+ bool fragStencil = groupNdx == 6 || groupNdx == 18;
bool multiViewport = groupNdx == 7;
bool colorLayered = groupNdx == 8 || groupNdx == 9;
bool srLayered = groupNdx == 9 || groupNdx == 11;
bool sampleLocations = groupNdx == 14;
bool sampleShadingEnable = groupNdx == 15;
bool sampleShadingInput = groupNdx == 16;
+ bool useGeometryShader = (shaderCases[shaderNdx].count == 1u);
+ bool useMeshShader = (shaderCases[shaderNdx].count == 2u);
+ bool earlyAndLateTest = groupNdx == 17 || groupNdx == 18;
+
VkConservativeRasterizationModeEXT conservativeMode = (groupNdx == 3) ? VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT : VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT;
deUint32 numColorLayers = (colorLayered || multiView) ? 2u : 1u;
// Don't bother with geometry shader if we're not testing shader writes
- if (geomCases[geomNdx].count && !shdCases[shdNdx].count)
+ if (useGeometryShader && !shdCases[shdNdx].count)
continue;
// reduce number of tests
continue;
// Don't bother with geometry shader if we're testing conservative raster, sample mask, depth/stencil
- if (geomCases[geomNdx].count && (useApiSampleMask || useSampleMaskIn || consRast || fragDepth || fragStencil))
+ if (useGeometryShader && (useApiSampleMask || useSampleMaskIn || consRast || fragDepth || fragStencil))
continue;
// Don't bother with geometry shader if we're testing non-dynamic state
- if (geomCases[geomNdx].count && !dynCases[dynNdx].count)
+ if (useGeometryShader && !dynCases[dynNdx].count)
continue;
// Only test multiViewport/layered with shaderWritesRate
}, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
attCases[attNdx].usage, // AttachmentUsage attachmentUsage;
(bool)shdCases[shdNdx].count, // bool shaderWritesRate;
- (bool)geomCases[geomNdx].count, // bool geometryShader;
+ useGeometryShader, // bool geometryShader;
+ useMeshShader, // bool meshShader;
(bool)dynCases[dynNdx].count, // bool useDynamicState;
useApiSampleMask, // bool useApiSampleMask;
useSampleMaskIn, // bool useSampleMaskIn;
sampleShadingEnable, // bool sampleShadingEnable;
sampleShadingInput, // bool sampleShadingInput;
false, // bool sampleMaskTest;
+ earlyAndLateTest, // bool earlyAndLateTest;
+ false, // bool garbageAttachment;
};
- sampGroup->addChild(new FSRTestCase(testCtx, geomCases[geomNdx].name, geomCases[geomNdx].description, c));
+ sampGroup->addChild(new FSRTestCase(testCtx, shaderCases[shaderNdx].name, shaderCases[shaderNdx].description, c));
}
extGroup->addChild(sampGroup.release());
}
parentGroup->addChild(group.release());
}
- if (!groupParams->useSecondaryCmdBuffer)
{
de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "misc_tests", "Single tests that don't need to be part of above test matrix"));
- group->addChild(new FSRTestCase(testCtx, "sample_mask_test", "", {
- groupParams, // SharedGroupParams groupParams;
- 123, // deInt32 seed;
- {32, 33}, // VkExtent2D framebufferDim;
- VK_SAMPLE_COUNT_4_BIT, // VkSampleCountFlagBits samples;
- {
- VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
- VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR
- }, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
- AttachmentUsage::NO_ATTACHMENT, // AttachmentUsage attachmentUsage;
- true, // bool shaderWritesRate;
- false, // bool geometryShader;
- false, // bool useDynamicState;
- true, // bool useApiSampleMask;
- false, // bool useSampleMaskIn;
- false, // bool conservativeEnable;
- VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, // VkConservativeRasterizationModeEXT conservativeMode;
- false, // bool useDepthStencil;
- false, // bool fragDepth;
- false, // bool fragStencil;
- false, // bool multiViewport;
- false, // bool colorLayered;
- false, // bool srLayered;
- 1u, // deUint32 numColorLayers;
- false, // bool multiView;
- false, // bool correlationMask;
- false, // bool interlock;
- false, // bool sampleLocations;
- false, // bool sampleShadingEnable;
- false, // bool sampleShadingInput;
- true, // bool sampleMaskTest;
- }));
+
+ if (!groupParams->useSecondaryCmdBuffer)
+ {
+ group->addChild(new FSRTestCase(testCtx, "sample_mask_test", "", {
+ groupParams, // SharedGroupParams groupParams;
+ 123, // deInt32 seed;
+ {32, 33}, // VkExtent2D framebufferDim;
+ VK_SAMPLE_COUNT_4_BIT, // VkSampleCountFlagBits samples;
+ {
+ VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
+ VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR
+ }, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
+ AttachmentUsage::NO_ATTACHMENT, // AttachmentUsage attachmentUsage;
+ true, // bool shaderWritesRate;
+ false, // bool geometryShader;
+ false, // bool meshShader;
+ false, // bool useDynamicState;
+ true, // bool useApiSampleMask;
+ false, // bool useSampleMaskIn;
+ false, // bool conservativeEnable;
+ VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, // VkConservativeRasterizationModeEXT conservativeMode;
+ false, // bool useDepthStencil;
+ false, // bool fragDepth;
+ false, // bool fragStencil;
+ false, // bool multiViewport;
+ false, // bool colorLayered;
+ false, // bool srLayered;
+ 1u, // deUint32 numColorLayers;
+ false, // bool multiView;
+ false, // bool correlationMask;
+ false, // bool interlock;
+ false, // bool sampleLocations;
+ false, // bool sampleShadingEnable;
+ false, // bool sampleShadingInput;
+ true, // bool sampleMaskTest;
+ false, // bool earlyAndLateTest;
+ false, // bool garbageAttachment;
+ }));
+ }
+
+#ifndef CTS_USES_VULKANSC
+ if (groupParams->useDynamicRendering && groupParams->pipelineConstructionType != vk::PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC)
+ {
+ group->addChild(new FSRTestCase(testCtx, "garbage_color_attachment", "", {
+ groupParams, // SharedGroupParams groupParams;
+ 123, // deInt32 seed;
+ {32, 33}, // VkExtent2D framebufferDim;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ {
+ VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR,
+ VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR
+ }, // VkFragmentShadingRateCombinerOpKHR combinerOp[2];
+ AttachmentUsage::NO_ATTACHMENT, // AttachmentUsage attachmentUsage;
+ false, // bool shaderWritesRate;
+ false, // bool geometryShader;
+ false, // bool meshShader;
+ false, // bool useDynamicState;
+ false, // bool useApiSampleMask;
+ false, // bool useSampleMaskIn;
+ false, // bool conservativeEnable;
+ VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT, // VkConservativeRasterizationModeEXT conservativeMode;
+ false, // bool useDepthStencil;
+ false, // bool fragDepth;
+ false, // bool fragStencil;
+ false, // bool multiViewport;
+ false, // bool colorLayered;
+ false, // bool srLayered;
+ 1u, // deUint32 numColorLayers;
+ false, // bool multiView;
+ false, // bool correlationMask;
+ false, // bool interlock;
+ false, // bool sampleLocations;
+ false, // bool sampleShadingEnable;
+ false, // bool sampleShadingInput;
+ false, // bool sampleMaskTest;
+ false, // bool earlyAndLateTest;
+ true, // bool garbageAttachment;
+ }));
+ }
+#endif // CTS_USES_VULKANSC
parentGroup->addChild(group.release());
}