--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief VK_AMD_shader_explicit_vertex_parameter tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktDrawExplicitVertexParameterTests.hpp"
+
+#include "vktDrawBaseClass.hpp"
+#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkTypeUtil.hpp"
+#include "vktTestGroupUtil.hpp"
+
+#include "vkObjUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkTypeUtil.hpp"
+
+#include "deDefs.h"
+#include "deRandom.hpp"
+#include "deString.h"
+#include "deMath.h"
+
+#include "tcuTestCase.hpp"
+#include "tcuRGBA.hpp"
+#include "tcuTextureUtil.hpp"
+#include "tcuImageCompare.hpp"
+#include "tcuStringTemplate.hpp"
+
+#include "rrRenderer.hpp"
+
+#include <string>
+#include <sstream>
+
+namespace vkt
+{
+namespace Draw
+{
+namespace
+{
+using namespace vk;
+using namespace std;
+
+enum Interpolation
+{
+ SMOOTH = 0,
+ NOPERSPECTIVE = 1,
+};
+
+enum AuxiliaryQualifier
+{
+ AUX_NONE = 0,
+ AUX_CENTROID = 1,
+ AUX_SAMPLE = 2,
+};
+
+
+enum
+{
+ WIDTH = 16,
+ HEIGHT = 16
+};
+
+struct PositionValueVertex {
+ PositionValueVertex(tcu::Vec4 pos, float val)
+ : position(pos)
+ , value(val)
+ {};
+public:
+ tcu::Vec4 position;
+ float value;
+};
+
+struct DrawParams
+{
+ Interpolation interpolation;
+ vk::VkSampleCountFlagBits samples;
+ AuxiliaryQualifier auxiliaryStorage;
+};
+
+const char* interpolationToString (Interpolation interpolation)
+{
+ switch (interpolation)
+ {
+ case SMOOTH:
+ return "smooth";
+ case NOPERSPECTIVE:
+ return "noperspective";
+ default:
+ DE_FATAL("Invalid interpolation enum");
+ }
+
+ return "";
+}
+
+std::string barycentricVariableString (Interpolation interpolation, AuxiliaryQualifier aux)
+{
+ std::ostringstream name;
+ name << "gl_BaryCoord";
+ switch (interpolation)
+ {
+ case SMOOTH:
+ name << "Smooth";
+ break;
+ case NOPERSPECTIVE:
+ name << "NoPersp";
+ break;
+ default:
+ DE_FATAL("Invalid interpolation enum");
+ }
+
+ switch (aux)
+ {
+ case AUX_CENTROID:
+ name << "Centroid";
+ break;
+ case AUX_SAMPLE:
+ name << "Sample";
+ break;
+ case AUX_NONE:
+ name << "";
+ break;
+ default:
+ DE_FATAL("Invalid auxiliary storage qualifier enum");
+ }
+ name << "AMD";
+ return name.str();
+}
+
+const char* auxiliaryQualifierToString (AuxiliaryQualifier aux)
+{
+ switch (aux)
+ {
+ case AUX_CENTROID:
+ return "centroid";
+ case AUX_SAMPLE:
+ return "sample";
+ case AUX_NONE:
+ return "";
+ default:
+ DE_FATAL("Invalid auxiliary storage qualifier enum");
+ }
+
+ return "";
+}
+
+std::string getTestName (DrawParams params)
+{
+ std::ostringstream name;
+
+ name << interpolationToString(params.interpolation) << "_";
+
+ if (params.auxiliaryStorage != AUX_NONE)
+ name << auxiliaryQualifierToString(params.auxiliaryStorage) << "_";
+
+ name << "samples_" << de::toString(params.samples);
+
+ return name.str();
+}
+
+class DrawTestInstance : public TestInstance
+{
+public:
+ DrawTestInstance (Context& context, const DrawParams& data);
+ ~DrawTestInstance (void);
+ tcu::TestStatus iterate (void);
+private:
+ DrawParams m_data;
+};
+
+DrawTestInstance::DrawTestInstance (Context& context, const DrawParams& data)
+ : vkt::TestInstance (context)
+ , m_data (data)
+{
+}
+
+DrawTestInstance::~DrawTestInstance (void)
+{
+}
+
+class DrawTestCase : public TestCase
+{
+ public:
+ DrawTestCase (tcu::TestContext& context, const char* name, const char* desc, const DrawParams data);
+ ~DrawTestCase (void);
+ virtual void initPrograms (SourceCollections& programCollection) const;
+ virtual TestInstance* createInstance (Context& context) const;
+ virtual void checkSupport (Context& context) const;
+
+private:
+ DrawParams m_data;
+};
+
+DrawTestCase::DrawTestCase (tcu::TestContext& context, const char* name, const char* desc, const DrawParams data)
+ : vkt::TestCase (context, name, desc)
+ , m_data (data)
+{
+}
+
+DrawTestCase::~DrawTestCase (void)
+{
+}
+
+void DrawTestCase::checkSupport(Context &context) const
+{
+ context.requireDeviceFunctionality("VK_AMD_shader_explicit_vertex_parameter");
+
+ if ((context.getDeviceProperties().limits.framebufferColorSampleCounts & m_data.samples) == 0)
+ TCU_THROW(NotSupportedError, "framebufferColorSampleCounts: sample count not supported");
+}
+
+void DrawTestCase::initPrograms (SourceCollections& programCollection) const
+{
+ const deUint32 numValues = WIDTH * HEIGHT * m_data.samples;
+
+ const tcu::StringTemplate vertShader (string(
+ "#version 450\n"
+ "#extension GL_AMD_shader_explicit_vertex_parameter : require\n"
+ "\n"
+ "layout(location = 0) in vec4 in_position;\n"
+ "layout(location = 1) in float in_data;\n"
+ "layout(location = 0) __explicitInterpAMD out float out_data_explicit;\n"
+ "layout(location = 1) ${auxqualifier} ${qualifier} out float out_data_${qualifier};\n"
+ "\n"
+ "out gl_PerVertex {\n"
+ " vec4 gl_Position;\n"
+ " float gl_PointSize;\n"
+ "};\n"
+ "\n"
+ "void main() {\n"
+ " gl_PointSize = 1.0;\n"
+ " gl_Position = in_position;\n"
+ " out_data_explicit = in_data;\n"
+ " out_data_${qualifier} = in_data;\n"
+ "}\n"));
+
+ const tcu::StringTemplate fragShader (string(
+ "#version 450\n"
+ "#extension GL_AMD_shader_explicit_vertex_parameter : require\n"
+ "\n"
+ "layout(location = 0) __explicitInterpAMD in float in_data_explicit;\n"
+ "layout(location = 1) ${auxqualifier} ${qualifier} in float in_data_${qualifier};\n"
+ "layout(location = 0) out vec4 out_color;\n"
+ "layout (binding = 0, std140) writeonly buffer Output {\n"
+ " vec4 values [${numValues}];\n"
+ "} sb_out;\n"
+ "\n"
+ "void main()\n"
+ "{\n"
+ " uint index = (uint(gl_FragCoord.y) * ${width} * ${samples}) + uint(gl_FragCoord.x) * ${samples} + gl_SampleID;\n"
+ " // Barycentric coodinates (I, J, K)\n"
+ " vec3 bary_coord = vec3(${barycoord}.x, ${barycoord}.y, 1.0f - ${barycoord}.x - ${barycoord}.y);\n"
+ "\n"
+ " // Vertex 0 -> (I = 0, J = 0, K = 1)\n"
+ " float data0 = interpolateAtVertexAMD(in_data_explicit, 0);\n"
+ " // Vertex 1 -> (I = 1, J = 0, K = 0)\n"
+ " float data1 = interpolateAtVertexAMD(in_data_explicit, 1);\n"
+ " // Vertex 1 -> (I = 0, J = 1, K = 0)\n"
+ " float data2 = interpolateAtVertexAMD(in_data_explicit, 2);\n"
+ " // Match data component with barycentric coordinate\n"
+ " vec3 data = vec3(data1, data2, data0);\n"
+ "\n"
+ " float res = (bary_coord.x * data.x) + (bary_coord.y * data.y) + (bary_coord.z * data.z);\n"
+ " float expected = in_data_${qualifier};\n"
+ "\n"
+ " sb_out.values[ index ] = vec4(expected, res, 0u, 0u);\n"
+ "\n"
+ " const float threshold = 0.0005f;\n"
+ " if (abs(res - expected) < threshold)\n"
+ " out_color = vec4(0.0f, 1.0f, 0.0f, 1.0f);\n"
+ " else\n"
+ " out_color = vec4(1.0f, 0.0f, 0.0f, 1.0f);\n"
+ "}\n"));
+
+ map<string, string> attributes;
+ attributes["width"] = de::toString(WIDTH);
+ attributes["numValues"] = de::toString(numValues * m_data.samples);
+ attributes["qualifier"] = interpolationToString(m_data.interpolation);
+ attributes["auxqualifier"] = auxiliaryQualifierToString(m_data.auxiliaryStorage);
+ attributes["barycoord"] = barycentricVariableString(m_data.interpolation, m_data.auxiliaryStorage);
+ attributes["samples"] = de::toString(m_data.samples);
+
+ programCollection.glslSources.add("vert") << glu::VertexSource(vertShader.specialize(attributes));
+ programCollection.glslSources.add("frag") << glu::FragmentSource(fragShader.specialize(attributes));
+}
+
+TestInstance* DrawTestCase::createInstance (Context& context) const
+{
+ return new DrawTestInstance(context, m_data);
+}
+
+tcu::TestStatus DrawTestInstance::iterate (void)
+{
+ de::SharedPtr<Image> colorTargetImage;
+ de::SharedPtr<Image> multisampleTargetImage;
+ tcu::TestLog &log = m_context.getTestContext().getLog();
+
+ // Run two iterations with shaders that have different interpolation decorations. Images should still match.
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const CmdPoolCreateInfo cmdPoolCreateInfo (m_context.getUniversalQueueFamilyIndex());
+ Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
+ Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+ const Unique<VkShaderModule> vs (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
+ const Unique<VkShaderModule> fs (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
+ de::SharedPtr<Buffer> vertexBuffer;
+ de::SharedPtr<Buffer> ssboBuffer;
+ Move<VkRenderPass> renderPass;
+ Move<VkImageView> colorTargetView;
+ Move<VkImageView> multisampleTargetView;
+ Move<VkFramebuffer> framebuffer;
+ Move<VkPipeline> pipeline;
+ Move<VkPipelineLayout> pipelineLayout;
+ Move<VkDescriptorPool> descriptorPool;
+ Move<VkDescriptorSet> descriptorSet;
+ Move<VkDescriptorSetLayout> descriptorSetLayout;
+
+ vk::VkFormat imageFormat = VK_FORMAT_R8G8B8A8_UNORM;
+ const deUint32 numValues = WIDTH * HEIGHT * m_data.samples;
+ const deBool useMultisampling = m_data.samples != VK_SAMPLE_COUNT_1_BIT;
+
+ // Create color buffer images.
+ {
+ const VkExtent3D targetImageExtent = { WIDTH, HEIGHT, 1 };
+ const ImageCreateInfo targetImageCreateInfo (VK_IMAGE_TYPE_2D, imageFormat, targetImageExtent, 1, 1, VK_SAMPLE_COUNT_1_BIT,
+ VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
+ colorTargetImage = Image::createAndAlloc(vk, device, targetImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
+
+ if (useMultisampling)
+ {
+ const ImageCreateInfo multisampleTargetImageCreateInfo (VK_IMAGE_TYPE_2D, imageFormat, targetImageExtent, 1, 1, m_data.samples,
+ VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
+ multisampleTargetImage = Image::createAndAlloc(vk, device, multisampleTargetImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
+ }
+ }
+
+ // Create render pass and frame buffer.
+ {
+ const ImageViewCreateInfo colorTargetViewInfo (colorTargetImage->object(), VK_IMAGE_VIEW_TYPE_2D, imageFormat);
+ colorTargetView = createImageView(vk, device, &colorTargetViewInfo);
+
+ RenderPassCreateInfo renderPassCreateInfo;
+ renderPassCreateInfo.addAttachment(AttachmentDescription(imageFormat,
+ VK_SAMPLE_COUNT_1_BIT,
+ VK_ATTACHMENT_LOAD_OP_LOAD,
+ VK_ATTACHMENT_STORE_OP_STORE,
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+ VK_ATTACHMENT_STORE_OP_STORE,
+ VK_IMAGE_LAYOUT_UNDEFINED,
+ VK_IMAGE_LAYOUT_GENERAL));
+
+ const VkAttachmentReference colorAttachmentRef = { 0u, VK_IMAGE_LAYOUT_GENERAL };
+ const VkAttachmentReference multisampleAttachmentRef = { 1u, VK_IMAGE_LAYOUT_GENERAL };
+ vector<VkImageView> colorAttachments;
+ colorAttachments.push_back(*colorTargetView);
+
+ if (useMultisampling)
+ {
+ const ImageViewCreateInfo multisamplingTargetViewInfo (multisampleTargetImage->object(),
+ vk::VK_IMAGE_VIEW_TYPE_2D,
+ imageFormat);
+
+
+ multisampleTargetView = createImageView(vk, device, &multisamplingTargetViewInfo);
+ colorAttachments.push_back(*multisampleTargetView);
+
+ renderPassCreateInfo.addAttachment(AttachmentDescription(imageFormat,
+ m_data.samples,
+ vk::VK_ATTACHMENT_LOAD_OP_CLEAR,
+ vk::VK_ATTACHMENT_STORE_OP_STORE,
+ vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+ vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,
+ vk::VK_IMAGE_LAYOUT_UNDEFINED,
+ vk::VK_IMAGE_LAYOUT_GENERAL));
+ }
+
+ renderPassCreateInfo.addSubpass(SubpassDescription(VK_PIPELINE_BIND_POINT_GRAPHICS,
+ 0,
+ 0,
+ DE_NULL,
+ 1u,
+ useMultisampling ? &multisampleAttachmentRef : &colorAttachmentRef,
+ useMultisampling ? &colorAttachmentRef : DE_NULL,
+ AttachmentReference(),
+ 0,
+ DE_NULL));
+
+ renderPass = createRenderPass(vk, device, &renderPassCreateInfo);
+
+ const FramebufferCreateInfo framebufferCreateInfo (*renderPass, colorAttachments, WIDTH, HEIGHT, 1);
+ framebuffer = createFramebuffer(vk, device, &framebufferCreateInfo);
+ }
+
+ // Create vertex buffer.
+ {
+ const PositionValueVertex vertices[] =
+ {
+ PositionValueVertex(
+ tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f), // Coord
+ float(1.0f)), // Value
+
+ PositionValueVertex(
+ tcu::Vec4(-1.0f, -1.0f, 0.25f, 0.75f), // Coord
+ float(0.0f)), // Value
+ PositionValueVertex(
+ tcu::Vec4( 1.0f, 1.0f, 0.0f, 2.0f), // Coord
+ float(0.5f)), // Value
+ PositionValueVertex(
+ tcu::Vec4( 1.0f, -1.0f, 1.0f, 0.5f), // Coord
+ float(1.0f)), // Value
+ };
+
+ const VkDeviceSize dataSize = DE_LENGTH_OF_ARRAY(vertices) * sizeof(PositionValueVertex);
+ vertexBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
+ deUint8* ptr = reinterpret_cast<deUint8*>(vertexBuffer->getBoundMemory().getHostPtr());
+
+ deMemcpy(ptr, vertices, static_cast<size_t>(dataSize));
+ flushMappedMemoryRange(vk, device, vertexBuffer->getBoundMemory().getMemory(), vertexBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
+ }
+
+ // Create SSBO buffer
+ {
+ const VkDeviceSize dataSize = sizeof(tcu::Vec4) * numValues;
+ ssboBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
+ deUint8* ptr = reinterpret_cast<deUint8*>(ssboBuffer->getBoundMemory().getHostPtr());
+
+ deMemset(ptr, 0, static_cast<size_t>(dataSize));
+ flushMappedMemoryRange(vk, device, ssboBuffer->getBoundMemory().getMemory(), ssboBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
+ }
+
+ // Create Descriptor Set layout
+ {
+ descriptorSetLayout = DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT)
+ .build(vk, device);
+ }
+
+ // Create Descriptor Set
+ {
+ descriptorPool = DescriptorPoolBuilder()
+ .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
+ .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
+
+ descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);
+
+ const VkDescriptorBufferInfo bufferInfo =
+ {
+ ssboBuffer->object(), // VkBuffer buffer;
+ 0u, // VkDeviceSize offset;
+ VK_WHOLE_SIZE // VkDeviceSize range;
+ };
+
+ DescriptorSetUpdateBuilder()
+ .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &bufferInfo)
+ .update(vk, device);
+ }
+
+ // Create pipeline
+ {
+ const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState;
+
+ VkViewport viewport = makeViewport(WIDTH, HEIGHT);
+ VkRect2D scissor = makeRect2D(WIDTH, HEIGHT);
+
+ const VkVertexInputBindingDescription vertexInputBindingDescription = { 0, (deUint32)(sizeof(tcu::Vec4) + sizeof(float)), VK_VERTEX_INPUT_RATE_VERTEX };
+
+ const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
+ {
+ { 0u, 0u, vk::VK_FORMAT_R32G32B32A32_SFLOAT, 0u },
+ { 1u, 0u, vk::VK_FORMAT_R32_SFLOAT, (deUint32)(sizeof(float)* 4) }
+ };
+
+ PipelineCreateInfo::VertexInputState vertexInputState = PipelineCreateInfo::VertexInputState(1, &vertexInputBindingDescription, 2, vertexInputAttributeDescriptions);
+
+ pipelineLayout = makePipelineLayout (vk, device, *descriptorSetLayout);
+
+ PipelineCreateInfo pipelineCreateInfo(*pipelineLayout, *renderPass, 0, 0);
+ pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT));
+ pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
+ pipelineCreateInfo.addState(PipelineCreateInfo::VertexInputState(vertexInputState));
+ pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP));
+ pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &vkCbAttachmentState));
+ pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, vector<VkViewport>(1, viewport), vector<VkRect2D>(1, scissor)));
+ pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
+ pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
+ pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState(m_data.samples));
+
+ pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
+ }
+
+ // Queue draw and read results.
+ {
+ const VkQueue queue = m_context.getUniversalQueue();
+ const ImageSubresourceRange subresourceRange (VK_IMAGE_ASPECT_COLOR_BIT);
+ const tcu::Vec4 clearColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
+ const VkRect2D renderArea = makeRect2D(WIDTH, HEIGHT);
+ const VkDeviceSize vertexBufferOffset = 0;
+ const VkBuffer buffer = vertexBuffer->object();
+
+ vector<VkClearValue> clearColors;
+ clearColors.push_back(makeClearValueColor(clearColor));
+
+ if (useMultisampling)
+ clearColors.push_back(makeClearValueColor(clearColor));
+
+ beginCommandBuffer(vk, *cmdBuffer, 0u);
+ const VkRenderPassBeginInfo renderPassBeginInfo =
+ {
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *renderPass, // VkRenderPass renderPass;
+ *framebuffer, // VkFramebuffer framebuffer;
+ renderArea, // VkRect2D renderArea;
+ (deUint32)clearColors.size(), // deUint32 clearValueCount;
+ clearColors.data(), // const VkClearValue* pClearValues;
+ };
+
+ vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+ vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &buffer, &vertexBufferOffset);
+ vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
+ vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
+ vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
+ endRenderPass(vk, *cmdBuffer);
+ endCommandBuffer(vk, *cmdBuffer);
+
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
+ }
+
+ qpTestResult res = QP_TEST_RESULT_PASS;
+
+ {
+ const Allocation& resultAlloc = ssboBuffer->getBoundMemory();
+ invalidateAlloc(vk, device, resultAlloc);
+
+ const tcu::Vec4* ptr = reinterpret_cast<tcu::Vec4*>(resultAlloc.getHostPtr());
+ for (deUint32 valueNdx = 0u; valueNdx < numValues; valueNdx++)
+ {
+ if (deFloatAbs(ptr[valueNdx].x() - ptr[valueNdx].y()) > 0.0005f)
+ {
+ log << tcu::TestLog::Message << "Expected value " << valueNdx << " is " << ptr[valueNdx].x() << ", got " << ptr[valueNdx].y()
+ << tcu::TestLog::EndMessage;
+ res = QP_TEST_RESULT_FAIL;
+ }
+ }
+ }
+
+ return tcu::TestStatus(res, qpGetTestResultName(res));
+}
+
+void createTests (tcu::TestCaseGroup* testGroup)
+{
+ tcu::TestContext& testCtx = testGroup->getTestContext();
+
+ const VkSampleCountFlagBits samples[] =
+ {
+ VK_SAMPLE_COUNT_1_BIT,
+ VK_SAMPLE_COUNT_2_BIT,
+ VK_SAMPLE_COUNT_4_BIT,
+ VK_SAMPLE_COUNT_8_BIT,
+ VK_SAMPLE_COUNT_16_BIT,
+ VK_SAMPLE_COUNT_32_BIT,
+ VK_SAMPLE_COUNT_64_BIT,
+ };
+
+ const Interpolation interTypes[] =
+ {
+ SMOOTH,
+ NOPERSPECTIVE
+ };
+
+ const AuxiliaryQualifier auxQualifiers[] =
+ {
+ AUX_NONE,
+ AUX_SAMPLE,
+ AUX_CENTROID,
+ };
+
+ for (deUint32 sampleNdx = 0; sampleNdx < DE_LENGTH_OF_ARRAY(samples); sampleNdx++)
+ for (deUint32 auxNdx = 0; auxNdx < DE_LENGTH_OF_ARRAY(auxQualifiers); auxNdx++)
+ for (deUint32 interNdx = 0; interNdx < DE_LENGTH_OF_ARRAY(interTypes); interNdx++)
+ {
+ if (samples[sampleNdx] == VK_SAMPLE_COUNT_1_BIT && auxQualifiers[auxNdx] != AUX_NONE)
+ continue;
+
+ const DrawParams params =
+ {
+ interTypes[interNdx],
+ samples[sampleNdx],
+ auxQualifiers[auxNdx],
+ };
+ testGroup->addChild(new DrawTestCase(testCtx, getTestName(params).c_str(), "", params));
+ }
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createExplicitVertexParameterTests (tcu::TestContext& testCtx)
+{
+ return createTestGroup(testCtx, "explicit_vertex_parameter", "Tests for VK_AMD_shader_explicit_vertex_parameter.", createTests);
+}
+
+} // Draw
+} // vkt
projects / platform / upstream / VK-GL-CTS.git / commitdiff