1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2015 The Khronos Group Inc. 6 * Copyright (c) 2015 Imagination Technologies Ltd. 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 * 20 *//*! 21 * \file 22 * \brief Vertex Input Tests 23 *//*--------------------------------------------------------------------*/ 24 25 #include "vktPipelineVertexInputTests.hpp" 26 #include "vktTestGroupUtil.hpp" 27 #include "vktPipelineClearUtil.hpp" 28 #include "vktPipelineImageUtil.hpp" 29 #include "vktPipelineVertexUtil.hpp" 30 #include "vktPipelineReferenceRenderer.hpp" 31 #include "vktTestCase.hpp" 32 #include "vktTestCaseUtil.hpp" 33 #include "vkImageUtil.hpp" 34 #include "vkMemUtil.hpp" 35 #include "vkPrograms.hpp" 36 #include "vkQueryUtil.hpp" 37 #include "vkRef.hpp" 38 #include "vkRefUtil.hpp" 39 #include "tcuFloat.hpp" 40 #include "tcuImageCompare.hpp" 41 #include "deFloat16.h" 42 #include "deMemory.h" 43 #include "deRandom.hpp" 44 #include "deStringUtil.hpp" 45 #include "deUniquePtr.hpp" 46 47 #include <sstream> 48 #include <vector> 49 50 namespace vkt 51 { 52 namespace pipeline 53 { 54 55 using namespace vk; 56 57 namespace 58 { 59 60 bool isSupportedVertexFormat (Context& context, VkFormat format) 61 { 62 if (isVertexFormatDouble(format) && !context.getDeviceFeatures().shaderFloat64) 63 return false; 64 65 VkFormatProperties formatProps; 66 deMemset(&formatProps, 0, sizeof(VkFormatProperties)); 67 context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), format, &formatProps); 68 69 return (formatProps.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) != 0u; 70 } 71 72 float getRepresentableDifferenceUnorm (VkFormat format) 73 { 74 DE_ASSERT(isVertexFormatUnorm(format) || isVertexFormatSRGB(format)); 75 76 return 1.0f / float((1 << (getVertexFormatComponentSize(format) * 8)) - 1); 77 } 78 79 float getRepresentableDifferenceSnorm (VkFormat format) 80 { 81 DE_ASSERT(isVertexFormatSnorm(format)); 82 83 return 1.0f / float((1 << (getVertexFormatComponentSize(format) * 8 - 1)) - 1); 84 } 85 86 deUint32 getNextMultipleOffset (deUint32 divisor, deUint32 value) 87 { 88 if (value % divisor == 0) 89 return 0; 90 else 91 return divisor - (value % divisor); 92 } 93 94 class VertexInputTest : public vkt::TestCase 95 { 96 public: 97 enum GlslType 98 { 99 GLSL_TYPE_INT, 100 GLSL_TYPE_IVEC2, 101 GLSL_TYPE_IVEC3, 102 GLSL_TYPE_IVEC4, 103 104 GLSL_TYPE_UINT, 105 GLSL_TYPE_UVEC2, 106 GLSL_TYPE_UVEC3, 107 GLSL_TYPE_UVEC4, 108 109 GLSL_TYPE_FLOAT, 110 GLSL_TYPE_VEC2, 111 GLSL_TYPE_VEC3, 112 GLSL_TYPE_VEC4, 113 GLSL_TYPE_MAT2, 114 GLSL_TYPE_MAT3, 115 GLSL_TYPE_MAT4, 116 117 GLSL_TYPE_DOUBLE, 118 GLSL_TYPE_DVEC2, 119 GLSL_TYPE_DVEC3, 120 GLSL_TYPE_DVEC4, 121 GLSL_TYPE_DMAT2, 122 GLSL_TYPE_DMAT3, 123 GLSL_TYPE_DMAT4, 124 125 GLSL_TYPE_COUNT 126 }; 127 128 enum GlslBasicType 129 { 130 GLSL_BASIC_TYPE_INT, 131 GLSL_BASIC_TYPE_UINT, 132 GLSL_BASIC_TYPE_FLOAT, 133 GLSL_BASIC_TYPE_DOUBLE 134 }; 135 136 enum BindingMapping 137 { 138 BINDING_MAPPING_ONE_TO_ONE, //!< Vertex input bindings will not contain data for more than one attribute. 139 BINDING_MAPPING_ONE_TO_MANY //!< Vertex input bindings can contain data for more than one attribute. 140 }; 141 142 enum AttributeLayout 143 { 144 ATTRIBUTE_LAYOUT_INTERLEAVED, //!< Attribute data is bundled together as if in a structure: [pos 0][color 0][pos 1][color 1]... 145 ATTRIBUTE_LAYOUT_SEQUENTIAL //!< Data for each attribute is laid out separately: [pos 0][pos 1]...[color 0][color 1]... 146 // Sequential only makes a difference if ONE_TO_MANY mapping is used (more than one attribute in a binding). 147 }; 148 149 struct AttributeInfo 150 { 151 GlslType glslType; 152 VkFormat vkType; 153 VkVertexInputRate inputRate; 154 }; 155 156 struct GlslTypeDescription 157 { 158 const char* name; 159 int vertexInputComponentCount; 160 int vertexInputCount; 161 GlslBasicType basicType; 162 }; 163 164 static const GlslTypeDescription s_glslTypeDescriptions[GLSL_TYPE_COUNT]; 165 166 VertexInputTest (tcu::TestContext& testContext, 167 const std::string& name, 168 const std::string& description, 169 const std::vector<AttributeInfo>& attributeInfos, 170 BindingMapping bindingMapping, 171 AttributeLayout attributeLayout); 172 173 virtual ~VertexInputTest (void) {} 174 virtual void initPrograms (SourceCollections& programCollection) const; 175 virtual TestInstance* createInstance (Context& context) const; 176 static bool isCompatibleType (VkFormat format, GlslType glslType); 177 178 private: 179 AttributeInfo getAttributeInfo (size_t attributeNdx) const; 180 size_t getNumAttributes (void) const; 181 std::string getGlslInputDeclarations (void) const; 182 std::string getGlslVertexCheck (void) const; 183 std::string getGlslAttributeConditions (const AttributeInfo& attributeInfo, const std::string attributeIndex) const; 184 static tcu::Vec4 getFormatThreshold (VkFormat format); 185 186 const std::vector<AttributeInfo> m_attributeInfos; 187 const BindingMapping m_bindingMapping; 188 const AttributeLayout m_attributeLayout; 189 const bool m_queryMaxAttributes; 190 bool m_usesDoubleType; 191 mutable size_t m_maxAttributes; 192 }; 193 194 class VertexInputInstance : public vkt::TestInstance 195 { 196 public: 197 struct VertexInputAttributeDescription 198 { 199 VertexInputTest::GlslType glslType; 200 int vertexInputIndex; 201 VkVertexInputAttributeDescription vkDescription; 202 }; 203 204 typedef std::vector<VertexInputAttributeDescription> AttributeDescriptionList; 205 206 VertexInputInstance (Context& context, 207 const AttributeDescriptionList& attributeDescriptions, 208 const std::vector<VkVertexInputBindingDescription>& bindingDescriptions, 209 const std::vector<VkDeviceSize>& bindingOffsets); 210 211 virtual ~VertexInputInstance (void); 212 virtual tcu::TestStatus iterate (void); 213 214 215 static void writeVertexInputData (deUint8* destPtr, const VkVertexInputBindingDescription& bindingDescription, const VkDeviceSize bindingOffset, const AttributeDescriptionList& attributes); 216 static void writeVertexInputValue (deUint8* destPtr, const VertexInputAttributeDescription& attributes, int indexId); 217 218 private: 219 tcu::TestStatus verifyImage (void); 220 221 private: 222 std::vector<VkBuffer> m_vertexBuffers; 223 std::vector<Allocation*> m_vertexBufferAllocs; 224 225 const tcu::UVec2 m_renderSize; 226 const VkFormat m_colorFormat; 227 228 Move<VkImage> m_colorImage; 229 de::MovePtr<Allocation> m_colorImageAlloc; 230 Move<VkImage> m_depthImage; 231 Move<VkImageView> m_colorAttachmentView; 232 Move<VkRenderPass> m_renderPass; 233 Move<VkFramebuffer> m_framebuffer; 234 235 Move<VkShaderModule> m_vertexShaderModule; 236 Move<VkShaderModule> m_fragmentShaderModule; 237 238 Move<VkPipelineLayout> m_pipelineLayout; 239 Move<VkPipeline> m_graphicsPipeline; 240 241 Move<VkCommandPool> m_cmdPool; 242 Move<VkCommandBuffer> m_cmdBuffer; 243 244 Move<VkFence> m_fence; 245 }; 246 247 const VertexInputTest::GlslTypeDescription VertexInputTest::s_glslTypeDescriptions[GLSL_TYPE_COUNT] = 248 { 249 { "int", 1, 1, GLSL_BASIC_TYPE_INT }, 250 { "ivec2", 2, 1, GLSL_BASIC_TYPE_INT }, 251 { "ivec3", 3, 1, GLSL_BASIC_TYPE_INT }, 252 { "ivec4", 4, 1, GLSL_BASIC_TYPE_INT }, 253 254 { "uint", 1, 1, GLSL_BASIC_TYPE_UINT }, 255 { "uvec2", 2, 1, GLSL_BASIC_TYPE_UINT }, 256 { "uvec3", 3, 1, GLSL_BASIC_TYPE_UINT }, 257 { "uvec4", 4, 1, GLSL_BASIC_TYPE_UINT }, 258 259 { "float", 1, 1, GLSL_BASIC_TYPE_FLOAT }, 260 { "vec2", 2, 1, GLSL_BASIC_TYPE_FLOAT }, 261 { "vec3", 3, 1, GLSL_BASIC_TYPE_FLOAT }, 262 { "vec4", 4, 1, GLSL_BASIC_TYPE_FLOAT }, 263 { "mat2", 2, 2, GLSL_BASIC_TYPE_FLOAT }, 264 { "mat3", 3, 3, GLSL_BASIC_TYPE_FLOAT }, 265 { "mat4", 4, 4, GLSL_BASIC_TYPE_FLOAT }, 266 267 { "double", 1, 1, GLSL_BASIC_TYPE_DOUBLE }, 268 { "dvec2", 2, 1, GLSL_BASIC_TYPE_DOUBLE }, 269 { "dvec3", 3, 1, GLSL_BASIC_TYPE_DOUBLE }, 270 { "dvec4", 4, 1, GLSL_BASIC_TYPE_DOUBLE }, 271 { "dmat2", 2, 2, GLSL_BASIC_TYPE_DOUBLE }, 272 { "dmat3", 3, 3, GLSL_BASIC_TYPE_DOUBLE }, 273 { "dmat4", 4, 4, GLSL_BASIC_TYPE_DOUBLE } 274 }; 275 276 277 VertexInputTest::VertexInputTest (tcu::TestContext& testContext, 278 const std::string& name, 279 const std::string& description, 280 const std::vector<AttributeInfo>& attributeInfos, 281 BindingMapping bindingMapping, 282 AttributeLayout attributeLayout) 283 284 : vkt::TestCase (testContext, name, description) 285 , m_attributeInfos (attributeInfos) 286 , m_bindingMapping (bindingMapping) 287 , m_attributeLayout (attributeLayout) 288 , m_queryMaxAttributes (attributeInfos.size() == 0) 289 , m_maxAttributes (16) 290 { 291 DE_ASSERT(m_attributeLayout == ATTRIBUTE_LAYOUT_INTERLEAVED || m_bindingMapping == BINDING_MAPPING_ONE_TO_MANY); 292 293 m_usesDoubleType = false; 294 295 for (size_t attributeNdx = 0; attributeNdx < m_attributeInfos.size(); attributeNdx++) 296 { 297 if (s_glslTypeDescriptions[m_attributeInfos[attributeNdx].glslType].basicType == GLSL_BASIC_TYPE_DOUBLE) 298 { 299 m_usesDoubleType = true; 300 break; 301 } 302 } 303 } 304 305 deUint32 getAttributeBinding (const VertexInputTest::BindingMapping bindingMapping, const VkVertexInputRate firstInputRate, const VkVertexInputRate inputRate, const deUint32 attributeNdx) 306 { 307 if (bindingMapping == VertexInputTest::BINDING_MAPPING_ONE_TO_ONE) 308 { 309 // Each attribute uses a unique binding 310 return attributeNdx; 311 } 312 else // bindingMapping == BINDING_MAPPING_ONE_TO_MANY 313 { 314 // Alternate between two bindings 315 return deUint32(firstInputRate + inputRate) % 2u; 316 } 317 } 318 319 //! Number of locations used up by an attribute. 320 deUint32 getConsumedLocations (const VertexInputTest::AttributeInfo& attributeInfo) 321 { 322 // double formats with more than 2 components will take 2 locations 323 const VertexInputTest::GlslType type = attributeInfo.glslType; 324 if ((type == VertexInputTest::GLSL_TYPE_DMAT2 || type == VertexInputTest::GLSL_TYPE_DMAT3 || type == VertexInputTest::GLSL_TYPE_DMAT4) && 325 (attributeInfo.vkType == VK_FORMAT_R64G64B64_SFLOAT || attributeInfo.vkType == VK_FORMAT_R64G64B64A64_SFLOAT)) 326 { 327 return 2u; 328 } 329 else 330 return 1u; 331 } 332 333 VertexInputTest::AttributeInfo VertexInputTest::getAttributeInfo (size_t attributeNdx) const 334 { 335 if (m_queryMaxAttributes) 336 { 337 AttributeInfo attributeInfo = 338 { 339 GLSL_TYPE_VEC4, 340 VK_FORMAT_R8G8B8A8_SNORM, 341 (attributeNdx % 2 == 0) ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE 342 }; 343 344 return attributeInfo; 345 } 346 else 347 { 348 return m_attributeInfos.at(attributeNdx); 349 } 350 } 351 352 size_t VertexInputTest::getNumAttributes (void) const 353 { 354 if (m_queryMaxAttributes) 355 return m_maxAttributes; 356 else 357 return m_attributeInfos.size(); 358 } 359 360 TestInstance* VertexInputTest::createInstance (Context& context) const 361 { 362 typedef VertexInputInstance::VertexInputAttributeDescription VertexInputAttributeDescription; 363 364 // Check upfront for maximum number of vertex input attributes 365 { 366 const InstanceInterface& vki = context.getInstanceInterface(); 367 const VkPhysicalDevice physDevice = context.getPhysicalDevice(); 368 const VkPhysicalDeviceLimits limits = getPhysicalDeviceProperties(vki, physDevice).limits; 369 370 const deUint32 maxAttributes = limits.maxVertexInputAttributes; 371 372 if (m_attributeInfos.size() > maxAttributes) 373 { 374 const std::string notSupportedStr = "Unsupported number of vertex input attributes, maxVertexInputAttributes: " + de::toString(maxAttributes); 375 TCU_THROW(NotSupportedError, notSupportedStr.c_str()); 376 } 377 378 // Use VkPhysicalDeviceLimits::maxVertexInputAttributes 379 if (m_queryMaxAttributes) 380 m_maxAttributes = maxAttributes; 381 } 382 383 // Create enough binding descriptions with random offsets 384 std::vector<VkVertexInputBindingDescription> bindingDescriptions; 385 std::vector<VkDeviceSize> bindingOffsets; 386 const size_t numAttributes = getNumAttributes(); 387 const size_t numBindings = (m_bindingMapping == BINDING_MAPPING_ONE_TO_ONE) ? numAttributes : ((numAttributes > 1) ? 2 : 1); 388 const VkVertexInputRate firstInputrate = getAttributeInfo(0).inputRate; 389 390 for (size_t bindingNdx = 0; bindingNdx < numBindings; ++bindingNdx) 391 { 392 // Bindings alternate between STEP_RATE_VERTEX and STEP_RATE_INSTANCE 393 const VkVertexInputRate inputRate = ((firstInputrate + bindingNdx) % 2 == 0) ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE; 394 395 // Stride will be updated when creating the attribute descriptions 396 const VkVertexInputBindingDescription bindingDescription = 397 { 398 static_cast<deUint32>(bindingNdx), // deUint32 binding; 399 0u, // deUint32 stride; 400 inputRate // VkVertexInputRate inputRate; 401 }; 402 403 bindingDescriptions.push_back(bindingDescription); 404 bindingOffsets.push_back(4 * bindingNdx); 405 } 406 407 std::vector<VertexInputAttributeDescription> attributeDescriptions; 408 deUint32 attributeLocation = 0; 409 std::vector<deUint32> attributeOffsets (bindingDescriptions.size(), 0); 410 std::vector<deUint32> attributeMaxSizes (bindingDescriptions.size(), 0); // max component or vector size, depending on which layout we are using 411 412 // To place the attributes sequentially we need to know the largest attribute and use its size in stride and offset calculations. 413 if (m_attributeLayout == ATTRIBUTE_LAYOUT_SEQUENTIAL) 414 for (size_t attributeNdx = 0; attributeNdx < numAttributes; ++attributeNdx) 415 { 416 const AttributeInfo& attributeInfo = getAttributeInfo(attributeNdx); 417 const deUint32 attributeBinding = getAttributeBinding(m_bindingMapping, firstInputrate, attributeInfo.inputRate, static_cast<deUint32>(attributeNdx)); 418 const deUint32 inputSize = getVertexFormatSize(attributeInfo.vkType); 419 420 attributeMaxSizes[attributeBinding] = de::max(attributeMaxSizes[attributeBinding], inputSize); 421 } 422 423 // Create attribute descriptions, assign them to bindings and update stride. 424 for (size_t attributeNdx = 0; attributeNdx < numAttributes; ++attributeNdx) 425 { 426 const AttributeInfo& attributeInfo = getAttributeInfo(attributeNdx); 427 const GlslTypeDescription& glslTypeDescription = s_glslTypeDescriptions[attributeInfo.glslType]; 428 const deUint32 inputSize = getVertexFormatSize(attributeInfo.vkType); 429 const deUint32 attributeBinding = getAttributeBinding(m_bindingMapping, firstInputrate, attributeInfo.inputRate, static_cast<deUint32>(attributeNdx)); 430 const deUint32 vertexCount = (attributeInfo.inputRate == VK_VERTEX_INPUT_RATE_VERTEX) ? (4 * 2) : 2; 431 432 VertexInputAttributeDescription attributeDescription = 433 { 434 attributeInfo.glslType, // GlslType glslType; 435 0, // int vertexInputIndex; 436 { 437 0u, // uint32_t location; 438 attributeBinding, // uint32_t binding; 439 attributeInfo.vkType, // VkFormat format; 440 0u, // uint32_t offset; 441 }, 442 }; 443 444 // Matrix types add each column as a separate attribute. 445 for (int descNdx = 0; descNdx < glslTypeDescription.vertexInputCount; ++descNdx) 446 { 447 attributeDescription.vertexInputIndex = descNdx; 448 attributeDescription.vkDescription.location = attributeLocation; 449 450 if (m_attributeLayout == ATTRIBUTE_LAYOUT_INTERLEAVED) 451 { 452 const deUint32 offsetToComponentAlignment = getNextMultipleOffset(getVertexFormatComponentSize(attributeInfo.vkType), 453 (deUint32)bindingOffsets[attributeBinding] + attributeOffsets[attributeBinding]); 454 attributeOffsets[attributeBinding] += offsetToComponentAlignment; 455 456 attributeDescription.vkDescription.offset = attributeOffsets[attributeBinding]; 457 attributeDescriptions.push_back(attributeDescription); 458 459 bindingDescriptions[attributeBinding].stride += offsetToComponentAlignment + inputSize; 460 attributeOffsets[attributeBinding] += inputSize; 461 attributeMaxSizes[attributeBinding] = de::max(attributeMaxSizes[attributeBinding], getVertexFormatComponentSize(attributeInfo.vkType)); 462 } 463 else // m_attributeLayout == ATTRIBUTE_LAYOUT_SEQUENTIAL 464 { 465 attributeDescription.vkDescription.offset = attributeOffsets[attributeBinding]; 466 attributeDescriptions.push_back(attributeDescription); 467 468 attributeOffsets[attributeBinding] += vertexCount * attributeMaxSizes[attributeBinding]; 469 } 470 471 attributeLocation += getConsumedLocations(attributeInfo); 472 } 473 474 if (m_attributeLayout == ATTRIBUTE_LAYOUT_SEQUENTIAL) 475 bindingDescriptions[attributeBinding].stride = attributeMaxSizes[attributeBinding]; 476 } 477 478 // Make sure the stride results in aligned access 479 for (size_t bindingNdx = 0; bindingNdx < bindingDescriptions.size(); ++bindingNdx) 480 { 481 if (attributeMaxSizes[bindingNdx] > 0) 482 bindingDescriptions[bindingNdx].stride += getNextMultipleOffset(attributeMaxSizes[bindingNdx], bindingDescriptions[bindingNdx].stride); 483 } 484 485 // Check upfront for maximum number of vertex input bindings 486 { 487 const InstanceInterface& vki = context.getInstanceInterface(); 488 const VkPhysicalDevice physDevice = context.getPhysicalDevice(); 489 const VkPhysicalDeviceLimits limits = getPhysicalDeviceProperties(vki, physDevice).limits; 490 491 const deUint32 maxBindings = limits.maxVertexInputBindings; 492 493 if (bindingDescriptions.size() > maxBindings) 494 { 495 const std::string notSupportedStr = "Unsupported number of vertex input bindings, maxVertexInputBindings: " + de::toString(maxBindings); 496 TCU_THROW(NotSupportedError, notSupportedStr.c_str()); 497 } 498 } 499 500 return new VertexInputInstance(context, attributeDescriptions, bindingDescriptions, bindingOffsets); 501 } 502 503 void VertexInputTest::initPrograms (SourceCollections& programCollection) const 504 { 505 std::ostringstream vertexSrc; 506 507 vertexSrc << "#version 440\n" 508 << "layout(constant_id = 0) const int numAttributes = " << m_maxAttributes << ";\n" 509 << getGlslInputDeclarations() 510 << "layout(location = 0) out highp vec4 vtxColor;\n" 511 << "out gl_PerVertex {\n" 512 << " vec4 gl_Position;\n" 513 << "};\n"; 514 515 // NOTE: double abs(double x) undefined in glslang ?? 516 if (m_usesDoubleType) 517 vertexSrc << "double abs (double x) { if (x < 0.0LF) return -x; else return x; }\n"; 518 519 vertexSrc << "void main (void)\n" 520 << "{\n" 521 << getGlslVertexCheck() 522 << "}\n"; 523 524 programCollection.glslSources.add("attribute_test_vert") << glu::VertexSource(vertexSrc.str()); 525 526 programCollection.glslSources.add("attribute_test_frag") << glu::FragmentSource( 527 "#version 440\n" 528 "layout(location = 0) in highp vec4 vtxColor;\n" 529 "layout(location = 0) out highp vec4 fragColor;\n" 530 "void main (void)\n" 531 "{\n" 532 " fragColor = vtxColor;\n" 533 "}\n"); 534 } 535 536 std::string VertexInputTest::getGlslInputDeclarations (void) const 537 { 538 std::ostringstream glslInputs; 539 deUint32 location = 0; 540 541 if (m_queryMaxAttributes) 542 { 543 const GlslTypeDescription& glslTypeDesc = s_glslTypeDescriptions[GLSL_TYPE_VEC4]; 544 glslInputs << "layout(location = 0) in " << glslTypeDesc.name << " attr[numAttributes];\n"; 545 } 546 else 547 { 548 for (size_t attributeNdx = 0; attributeNdx < m_attributeInfos.size(); attributeNdx++) 549 { 550 const GlslTypeDescription& glslTypeDesc = s_glslTypeDescriptions[m_attributeInfos[attributeNdx].glslType]; 551 552 glslInputs << "layout(location = " << location << ") in " << glslTypeDesc.name << " attr" << attributeNdx << ";\n"; 553 location += glslTypeDesc.vertexInputCount; 554 } 555 } 556 557 return glslInputs.str(); 558 } 559 560 std::string VertexInputTest::getGlslVertexCheck (void) const 561 { 562 std::ostringstream glslCode; 563 int totalInputComponentCount = 0; 564 565 glslCode << " int okCount = 0;\n"; 566 567 if (m_queryMaxAttributes) 568 { 569 const AttributeInfo attributeInfo = getAttributeInfo(0); 570 571 glslCode << " for (int checkNdx = 0; checkNdx < numAttributes; checkNdx++)\n" 572 << " {\n" 573 << " uint index = (checkNdx % 2 == 0) ? gl_VertexIndex : gl_InstanceIndex;\n"; 574 575 glslCode << getGlslAttributeConditions(attributeInfo, "checkNdx") 576 << " }\n"; 577 578 const int vertexInputCount = VertexInputTest::s_glslTypeDescriptions[attributeInfo.glslType].vertexInputCount; 579 totalInputComponentCount += vertexInputCount * VertexInputTest::s_glslTypeDescriptions[attributeInfo.glslType].vertexInputComponentCount; 580 581 glslCode << 582 " if (okCount == " << totalInputComponentCount << " * numAttributes)\n" 583 " {\n" 584 " if (gl_InstanceIndex == 0)\n" 585 " vtxColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 586 " else\n" 587 " vtxColor = vec4(0.0, 0.0, 1.0, 1.0);\n" 588 " }\n" 589 " else\n" 590 " {\n" 591 " vtxColor = vec4(okCount / float(" << totalInputComponentCount << " * numAttributes), 0.0f, 0.0f, 1.0);\n" << 592 " }\n\n" 593 " if (gl_InstanceIndex == 0)\n" 594 " {\n" 595 " if (gl_VertexIndex == 0) gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n" 596 " else if (gl_VertexIndex == 1) gl_Position = vec4(0.0, -1.0, 0.0, 1.0);\n" 597 " else if (gl_VertexIndex == 2) gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n" 598 " else if (gl_VertexIndex == 3) gl_Position = vec4(0.0, 1.0, 0.0, 1.0);\n" 599 " else gl_Position = vec4(0.0);\n" 600 " }\n" 601 " else\n" 602 " {\n" 603 " if (gl_VertexIndex == 0) gl_Position = vec4(0.0, -1.0, 0.0, 1.0);\n" 604 " else if (gl_VertexIndex == 1) gl_Position = vec4(1.0, -1.0, 0.0, 1.0);\n" 605 " else if (gl_VertexIndex == 2) gl_Position = vec4(0.0, 1.0, 0.0, 1.0);\n" 606 " else if (gl_VertexIndex == 3) gl_Position = vec4(1.0, 1.0, 0.0, 1.0);\n" 607 " else gl_Position = vec4(0.0);\n" 608 " }\n"; 609 } 610 else 611 { 612 for (size_t attributeNdx = 0; attributeNdx < m_attributeInfos.size(); attributeNdx++) 613 { 614 glslCode << getGlslAttributeConditions(m_attributeInfos[attributeNdx], de::toString(attributeNdx)); 615 616 const int vertexInputCount = VertexInputTest::s_glslTypeDescriptions[m_attributeInfos[attributeNdx].glslType].vertexInputCount; 617 totalInputComponentCount += vertexInputCount * VertexInputTest::s_glslTypeDescriptions[m_attributeInfos[attributeNdx].glslType].vertexInputComponentCount; 618 } 619 620 glslCode << 621 " if (okCount == " << totalInputComponentCount << ")\n" 622 " {\n" 623 " if (gl_InstanceIndex == 0)\n" 624 " vtxColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 625 " else\n" 626 " vtxColor = vec4(0.0, 0.0, 1.0, 1.0);\n" 627 " }\n" 628 " else\n" 629 " {\n" 630 " vtxColor = vec4(okCount / float(" << totalInputComponentCount << "), 0.0f, 0.0f, 1.0);\n" << 631 " }\n\n" 632 " if (gl_InstanceIndex == 0)\n" 633 " {\n" 634 " if (gl_VertexIndex == 0) gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n" 635 " else if (gl_VertexIndex == 1) gl_Position = vec4(0.0, -1.0, 0.0, 1.0);\n" 636 " else if (gl_VertexIndex == 2) gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n" 637 " else if (gl_VertexIndex == 3) gl_Position = vec4(0.0, 1.0, 0.0, 1.0);\n" 638 " else gl_Position = vec4(0.0);\n" 639 " }\n" 640 " else\n" 641 " {\n" 642 " if (gl_VertexIndex == 0) gl_Position = vec4(0.0, -1.0, 0.0, 1.0);\n" 643 " else if (gl_VertexIndex == 1) gl_Position = vec4(1.0, -1.0, 0.0, 1.0);\n" 644 " else if (gl_VertexIndex == 2) gl_Position = vec4(0.0, 1.0, 0.0, 1.0);\n" 645 " else if (gl_VertexIndex == 3) gl_Position = vec4(1.0, 1.0, 0.0, 1.0);\n" 646 " else gl_Position = vec4(0.0);\n" 647 " }\n"; 648 } 649 return glslCode.str(); 650 } 651 652 std::string VertexInputTest::getGlslAttributeConditions (const AttributeInfo& attributeInfo, const std::string attributeIndex) const 653 { 654 std::ostringstream glslCode; 655 std::ostringstream attributeVar; 656 const int componentCount = VertexInputTest::s_glslTypeDescriptions[attributeInfo.glslType].vertexInputComponentCount; 657 const int vertexInputCount = VertexInputTest::s_glslTypeDescriptions[attributeInfo.glslType].vertexInputCount; 658 const deUint32 totalComponentCount = componentCount * vertexInputCount; 659 const tcu::Vec4 threshold = getFormatThreshold(attributeInfo.vkType); 660 deUint32 componentIndex = 0; 661 const std::string indexStr = m_queryMaxAttributes ? "[" + attributeIndex + "]" : attributeIndex; 662 const std::string indentStr = m_queryMaxAttributes ? "\t\t" : "\t"; 663 std::string indexId; 664 665 if (m_queryMaxAttributes) 666 indexId = "index"; 667 else 668 indexId = (attributeInfo.inputRate == VK_VERTEX_INPUT_RATE_VERTEX) ? "gl_VertexIndex" : "gl_InstanceIndex"; 669 670 attributeVar << "attr" << indexStr; 671 672 glslCode << std::fixed; 673 674 for (int columnNdx = 0; columnNdx< vertexInputCount; columnNdx++) 675 { 676 for (int rowNdx = 0; rowNdx < componentCount; rowNdx++) 677 { 678 std::string accessStr; 679 { 680 // Build string representing the access to the attribute component 681 std::ostringstream accessStream; 682 accessStream << attributeVar.str(); 683 684 if (vertexInputCount == 1) 685 { 686 if (componentCount > 1) 687 accessStream << "[" << rowNdx << "]"; 688 } 689 else 690 { 691 accessStream << "[" << columnNdx << "][" << rowNdx << "]"; 692 } 693 694 accessStr = accessStream.str(); 695 } 696 697 if (isVertexFormatSint(attributeInfo.vkType)) 698 { 699 glslCode << indentStr << "if (" << accessStr << " == -(" << totalComponentCount << " * " << indexId << " + " << componentIndex << "))\n"; 700 } 701 else if (isVertexFormatUint(attributeInfo.vkType)) 702 { 703 glslCode << indentStr << "if (" << accessStr << " == uint(" << totalComponentCount << " * " << indexId << " + " << componentIndex << "))\n"; 704 } 705 else if (isVertexFormatSfloat(attributeInfo.vkType)) 706 { 707 if (VertexInputTest::s_glslTypeDescriptions[attributeInfo.glslType].basicType == VertexInputTest::GLSL_BASIC_TYPE_DOUBLE) 708 { 709 glslCode << indentStr << "if (abs(" << accessStr << " + double(0.01 * (" << totalComponentCount << ".0 * float(" << indexId << ") + " << componentIndex << ".0))) < double(" << threshold[rowNdx] << "))\n"; 710 } 711 else 712 { 713 glslCode << indentStr << "if (abs(" << accessStr << " + (0.01 * (" << totalComponentCount << ".0 * float(" << indexId << ") + " << componentIndex << ".0))) < " << threshold[rowNdx] << ")\n"; 714 } 715 } 716 else if (isVertexFormatSscaled(attributeInfo.vkType)) 717 { 718 glslCode << indentStr << "if (abs(" << accessStr << " + (" << totalComponentCount << ".0 * float(" << indexId << ") + " << componentIndex << ".0)) < " << threshold[rowNdx] << ")\n"; 719 } 720 else if (isVertexFormatUscaled(attributeInfo.vkType)) 721 { 722 glslCode << indentStr << "if (abs(" << accessStr << " - (" << totalComponentCount << ".0 * float(" << indexId << ") + " << componentIndex << ".0)) < " << threshold[rowNdx] << ")\n"; 723 } 724 else if (isVertexFormatSnorm(attributeInfo.vkType)) 725 { 726 const float representableDiff = getRepresentableDifferenceSnorm(attributeInfo.vkType); 727 728 glslCode << indentStr << "if (abs(" << accessStr << " - (-1.0 + " << representableDiff << " * (" << totalComponentCount << ".0 * float(" << indexId << ") + " << componentIndex << ".0))) < " << threshold[rowNdx] << ")\n"; 729 } 730 else if (isVertexFormatUnorm(attributeInfo.vkType) || isVertexFormatSRGB(attributeInfo.vkType)) 731 { 732 const float representableDiff = getRepresentableDifferenceUnorm(attributeInfo.vkType); 733 734 glslCode << indentStr << "if (abs(" << accessStr << " - " << "(" << representableDiff << " * (" << totalComponentCount << ".0 * float(" << indexId << ") + " << componentIndex << ".0))) < " << threshold[rowNdx] << ")\n"; 735 } 736 else 737 { 738 DE_ASSERT(false); 739 } 740 741 glslCode << indentStr << "\tokCount++;\n\n"; 742 743 componentIndex++; 744 } 745 } 746 return glslCode.str(); 747 } 748 749 tcu::Vec4 VertexInputTest::getFormatThreshold (VkFormat format) 750 { 751 using tcu::Vec4; 752 753 switch (format) 754 { 755 case VK_FORMAT_R32_SFLOAT: 756 case VK_FORMAT_R32G32_SFLOAT: 757 case VK_FORMAT_R32G32B32_SFLOAT: 758 case VK_FORMAT_R32G32B32A32_SFLOAT: 759 case VK_FORMAT_R64_SFLOAT: 760 case VK_FORMAT_R64G64_SFLOAT: 761 case VK_FORMAT_R64G64B64_SFLOAT: 762 case VK_FORMAT_R64G64B64A64_SFLOAT: 763 return Vec4(0.00001f); 764 765 default: 766 break; 767 } 768 769 if (isVertexFormatSnorm(format)) 770 { 771 return Vec4(1.5f * getRepresentableDifferenceSnorm(format)); 772 } 773 else if (isVertexFormatUnorm(format)) 774 { 775 return Vec4(1.5f * getRepresentableDifferenceUnorm(format)); 776 } 777 778 return Vec4(0.001f); 779 } 780 781 VertexInputInstance::VertexInputInstance (Context& context, 782 const AttributeDescriptionList& attributeDescriptions, 783 const std::vector<VkVertexInputBindingDescription>& bindingDescriptions, 784 const std::vector<VkDeviceSize>& bindingOffsets) 785 : vkt::TestInstance (context) 786 , m_renderSize (16, 16) 787 , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM) 788 { 789 DE_ASSERT(bindingDescriptions.size() == bindingOffsets.size()); 790 791 const DeviceInterface& vk = context.getDeviceInterface(); 792 const VkDevice vkDevice = context.getDevice(); 793 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); 794 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice())); 795 const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A }; 796 797 // Check upfront for unsupported features 798 for (size_t attributeNdx = 0; attributeNdx < attributeDescriptions.size(); attributeNdx++) 799 { 800 const VkVertexInputAttributeDescription& attributeDescription = attributeDescriptions[attributeNdx].vkDescription; 801 if (!isSupportedVertexFormat(context, attributeDescription.format)) 802 { 803 throw tcu::NotSupportedError(std::string("Unsupported format for vertex input: ") + getFormatName(attributeDescription.format)); 804 } 805 } 806 807 // Create color image 808 { 809 const VkImageCreateInfo colorImageParams = 810 { 811 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; 812 DE_NULL, // const void* pNext; 813 0u, // VkImageCreateFlags flags; 814 VK_IMAGE_TYPE_2D, // VkImageType imageType; 815 m_colorFormat, // VkFormat format; 816 { m_renderSize.x(), m_renderSize.y(), 1u }, // VkExtent3D extent; 817 1u, // deUint32 mipLevels; 818 1u, // deUint32 arrayLayers; 819 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 820 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; 821 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage; 822 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 823 1u, // deUint32 queueFamilyIndexCount; 824 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices; 825 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; 826 }; 827 828 m_colorImage = createImage(vk, vkDevice, &colorImageParams); 829 830 // Allocate and bind color image memory 831 m_colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_colorImage), MemoryRequirement::Any); 832 VK_CHECK(vk.bindImageMemory(vkDevice, *m_colorImage, m_colorImageAlloc->getMemory(), m_colorImageAlloc->getOffset())); 833 } 834 835 // Create color attachment view 836 { 837 const VkImageViewCreateInfo colorAttachmentViewParams = 838 { 839 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; 840 DE_NULL, // const void* pNext; 841 0u, // VkImageViewCreateFlags flags; 842 *m_colorImage, // VkImage image; 843 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType; 844 m_colorFormat, // VkFormat format; 845 componentMappingRGBA, // VkComponentMapping components; 846 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange; 847 }; 848 849 m_colorAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams); 850 } 851 852 // Create render pass 853 { 854 const VkAttachmentDescription colorAttachmentDescription = 855 { 856 0u, // VkAttachmentDescriptionFlags flags; 857 m_colorFormat, // VkFormat format; 858 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 859 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; 860 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; 861 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; 862 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; 863 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout; 864 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout; 865 }; 866 867 const VkAttachmentReference colorAttachmentReference = 868 { 869 0u, // deUint32 attachment; 870 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; 871 }; 872 873 const VkSubpassDescription subpassDescription = 874 { 875 0u, // VkSubpassDescriptionFlags flags; 876 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; 877 0u, // deUint32 inputAttachmentCount; 878 DE_NULL, // const VkAttachmentReference* pInputAttachments; 879 1u, // deUint32 colorAttachmentCount; 880 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments; 881 DE_NULL, // const VkAttachmentReference* pResolveAttachments; 882 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; 883 0u, // deUint32 preserveAttachmentCount; 884 DE_NULL // const VkAttachmentReference* pPreserveAttachments; 885 }; 886 887 const VkRenderPassCreateInfo renderPassParams = 888 { 889 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; 890 DE_NULL, // const void* pNext; 891 0u, // VkRenderPassCreateFlags flags; 892 1u, // deUint32 attachmentCount; 893 &colorAttachmentDescription, // const VkAttachmentDescription* pAttachments; 894 1u, // deUint32 subpassCount; 895 &subpassDescription, // const VkSubpassDescription* pSubpasses; 896 0u, // deUint32 dependencyCount; 897 DE_NULL // const VkSubpassDependency* pDependencies; 898 }; 899 900 m_renderPass = createRenderPass(vk, vkDevice, &renderPassParams); 901 } 902 903 // Create framebuffer 904 { 905 const VkFramebufferCreateInfo framebufferParams = 906 { 907 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; 908 DE_NULL, // const void* pNext; 909 0u, // VkFramebufferCreateFlags flags; 910 *m_renderPass, // VkRenderPass renderPass; 911 1u, // deUint32 attachmentCount; 912 &m_colorAttachmentView.get(), // const VkImageView* pAttachments; 913 (deUint32)m_renderSize.x(), // deUint32 width; 914 (deUint32)m_renderSize.y(), // deUint32 height; 915 1u // deUint32 layers; 916 }; 917 918 m_framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams); 919 } 920 921 // Create pipeline layout 922 { 923 const VkPipelineLayoutCreateInfo pipelineLayoutParams = 924 { 925 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 926 DE_NULL, // const void* pNext; 927 0u, // VkPipelineLayoutCreateFlags flags; 928 0u, // deUint32 setLayoutCount; 929 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts; 930 0u, // deUint32 pushConstantRangeCount; 931 DE_NULL // const VkPushConstantRange* pPushConstantRanges; 932 }; 933 934 m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams); 935 } 936 937 m_vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("attribute_test_vert"), 0); 938 m_fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("attribute_test_frag"), 0); 939 940 // Create specialization constant 941 deUint32 specializationData = static_cast<deUint32>(attributeDescriptions.size()); 942 943 const VkSpecializationMapEntry specializationMapEntry = 944 { 945 0, // uint32_t constantID 946 0, // uint32_t offset 947 sizeof(specializationData), // uint32_t size 948 }; 949 950 const VkSpecializationInfo specializationInfo = 951 { 952 1, // uint32_t mapEntryCount 953 &specializationMapEntry, // const void* pMapEntries 954 sizeof(specializationData), // size_t dataSize 955 &specializationData // const void* pData 956 }; 957 958 // Create pipeline 959 { 960 const VkPipelineShaderStageCreateInfo shaderStageParams[2] = 961 { 962 { 963 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 964 DE_NULL, // const void* pNext; 965 0u, // VkPipelineShaderStageCreateFlags flags; 966 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage; 967 *m_vertexShaderModule, // VkShaderModule module; 968 "main", // const char* pName; 969 &specializationInfo // const VkSpecializationInfo* pSpecializationInfo; 970 }, 971 { 972 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 973 DE_NULL, // const void* pNext; 974 0u, // VkPipelineShaderStageCreateFlags flags; 975 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage; 976 *m_fragmentShaderModule, // VkShaderModule module; 977 "main", // const char* pName; 978 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 979 } 980 }; 981 982 // Create vertex attribute array and check if their VK formats are supported 983 std::vector<VkVertexInputAttributeDescription> vkAttributeDescriptions; 984 for (size_t attributeNdx = 0; attributeNdx < attributeDescriptions.size(); attributeNdx++) 985 { 986 const VkVertexInputAttributeDescription& attributeDescription = attributeDescriptions[attributeNdx].vkDescription; 987 vkAttributeDescriptions.push_back(attributeDescription); 988 } 989 990 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams = 991 { 992 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; 993 DE_NULL, // const void* pNext; 994 0u, // VkPipelineVertexInputStateCreateFlags flags; 995 (deUint32)bindingDescriptions.size(), // deUint32 vertexBindingDescriptionCount; 996 bindingDescriptions.data(), // const VkVertexInputBindingDescription* pVertexBindingDescriptions; 997 (deUint32)vkAttributeDescriptions.size(), // deUint32 vertexAttributeDescriptionCount; 998 vkAttributeDescriptions.data() // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; 999 }; 1000 1001 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams = 1002 { 1003 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; 1004 DE_NULL, // const void* pNext; 1005 0u, // VkPipelineInputAssemblyStateCreateFlags flags; 1006 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology topology; 1007 false // VkBool32 primitiveRestartEnable; 1008 }; 1009 1010 const VkViewport viewport = 1011 { 1012 0.0f, // float x; 1013 0.0f, // float y; 1014 (float)m_renderSize.x(), // float width; 1015 (float)m_renderSize.y(), // float height; 1016 0.0f, // float minDepth; 1017 1.0f // float maxDepth; 1018 }; 1019 1020 const VkRect2D scissor = { { 0, 0 }, { m_renderSize.x(), m_renderSize.y() } }; 1021 1022 const VkPipelineViewportStateCreateInfo viewportStateParams = 1023 { 1024 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; 1025 DE_NULL, // const void* pNext; 1026 0u, // VkPipelineViewportStateCreateFlags flags; 1027 1u, // deUint32 viewportCount; 1028 &viewport, // const VkViewport* pViewports; 1029 1u, // deUint32 scissorCount; 1030 &scissor // const VkRect2D* pScissors; 1031 }; 1032 1033 const VkPipelineRasterizationStateCreateInfo rasterStateParams = 1034 { 1035 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType; 1036 DE_NULL, // const void* pNext; 1037 0u, // VkPipelineRasterizationStateCreateFlags flags; 1038 false, // VkBool32 depthClampEnable; 1039 false, // VkBool32 rasterizerDiscardEnable; 1040 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode; 1041 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode; 1042 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace; 1043 VK_FALSE, // VkBool32 depthBiasEnable; 1044 0.0f, // float depthBiasConstantFactor; 1045 0.0f, // float depthBiasClamp; 1046 0.0f, // float depthBiasSlopeFactor; 1047 1.0f, // float lineWidth; 1048 }; 1049 1050 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = 1051 { 1052 false, // VkBool32 blendEnable; 1053 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor; 1054 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor; 1055 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp; 1056 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor; 1057 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor; 1058 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp; 1059 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | // VkColorComponentFlags colorWriteMask; 1060 VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT 1061 }; 1062 1063 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams = 1064 { 1065 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; 1066 DE_NULL, // const void* pNext; 1067 0u, // VkPipelineColorBlendStateCreateFlags flags; 1068 false, // VkBool32 logicOpEnable; 1069 VK_LOGIC_OP_COPY, // VkLogicOp logicOp; 1070 1u, // deUint32 attachmentCount; 1071 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments; 1072 { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4]; 1073 }; 1074 1075 const VkPipelineMultisampleStateCreateInfo multisampleStateParams = 1076 { 1077 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; 1078 DE_NULL, // const void* pNext; 1079 0u, // VkPipelineMultisampleStateCreateFlags flags; 1080 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples; 1081 false, // VkBool32 sampleShadingEnable; 1082 0.0f, // float minSampleShading; 1083 DE_NULL, // const VkSampleMask* pSampleMask; 1084 false, // VkBool32 alphaToCoverageEnable; 1085 false // VkBool32 alphaToOneEnable; 1086 }; 1087 1088 VkPipelineDepthStencilStateCreateInfo depthStencilStateParams = 1089 { 1090 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType; 1091 DE_NULL, // const void* pNext; 1092 0u, // VkPipelineDepthStencilStateCreateFlags flags; 1093 false, // VkBool32 depthTestEnable; 1094 false, // VkBool32 depthWriteEnable; 1095 VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp; 1096 false, // VkBool32 depthBoundsTestEnable; 1097 false, // VkBool32 stencilTestEnable; 1098 // VkStencilOpState front; 1099 { 1100 VK_STENCIL_OP_KEEP, // VkStencilOp failOp; 1101 VK_STENCIL_OP_KEEP, // VkStencilOp passOp; 1102 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp; 1103 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; 1104 0u, // deUint32 compareMask; 1105 0u, // deUint32 writeMask; 1106 0u, // deUint32 reference; 1107 }, 1108 // VkStencilOpState back; 1109 { 1110 VK_STENCIL_OP_KEEP, // VkStencilOp failOp; 1111 VK_STENCIL_OP_KEEP, // VkStencilOp passOp; 1112 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp; 1113 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp; 1114 0u, // deUint32 compareMask; 1115 0u, // deUint32 writeMask; 1116 0u, // deUint32 reference; 1117 }, 1118 0.0f, // float minDepthBounds; 1119 1.0f, // float maxDepthBounds; 1120 }; 1121 1122 const VkGraphicsPipelineCreateInfo graphicsPipelineParams = 1123 { 1124 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; 1125 DE_NULL, // const void* pNext; 1126 0u, // VkPipelineCreateFlags flags; 1127 2u, // deUint32 stageCount; 1128 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages; 1129 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 1130 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 1131 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState; 1132 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState; 1133 &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState; 1134 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 1135 &depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 1136 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 1137 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState; 1138 *m_pipelineLayout, // VkPipelineLayout layout; 1139 *m_renderPass, // VkRenderPass renderPass; 1140 0u, // deUint32 subpass; 1141 0u, // VkPipeline basePipelineHandle; 1142 0u // deInt32 basePipelineIndex; 1143 }; 1144 1145 m_graphicsPipeline = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams); 1146 } 1147 1148 // Create vertex buffer 1149 { 1150 const VkBufferCreateInfo vertexBufferParams = 1151 { 1152 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; 1153 DE_NULL, // const void* pNext; 1154 0u, // VkBufferCreateFlags flags; 1155 4096u, // VkDeviceSize size; 1156 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage; 1157 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 1158 1u, // deUint32 queueFamilyIndexCount; 1159 &queueFamilyIndex // const deUint32* pQueueFamilyIndices; 1160 }; 1161 1162 // Upload data for each vertex input binding 1163 for (deUint32 bindingNdx = 0; bindingNdx < bindingDescriptions.size(); bindingNdx++) 1164 { 1165 Move<VkBuffer> vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams); 1166 de::MovePtr<Allocation> vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible); 1167 1168 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset())); 1169 1170 writeVertexInputData((deUint8*)vertexBufferAlloc->getHostPtr(), bindingDescriptions[bindingNdx], bindingOffsets[bindingNdx], attributeDescriptions); 1171 flushMappedMemoryRange(vk, vkDevice, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset(), vertexBufferParams.size); 1172 1173 m_vertexBuffers.push_back(vertexBuffer.disown()); 1174 m_vertexBufferAllocs.push_back(vertexBufferAlloc.release()); 1175 } 1176 } 1177 1178 // Create command pool 1179 m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex); 1180 1181 // Create command buffer 1182 { 1183 const VkCommandBufferBeginInfo cmdBufferBeginInfo = 1184 { 1185 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; 1186 DE_NULL, // const void* pNext; 1187 0u, // VkCommandBufferUsageFlags flags; 1188 (const VkCommandBufferInheritanceInfo*)DE_NULL, 1189 }; 1190 1191 const VkClearValue attachmentClearValue = defaultClearValue(m_colorFormat); 1192 1193 const VkRenderPassBeginInfo renderPassBeginInfo = 1194 { 1195 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType; 1196 DE_NULL, // const void* pNext; 1197 *m_renderPass, // VkRenderPass renderPass; 1198 *m_framebuffer, // VkFramebuffer framebuffer; 1199 { { 0, 0 }, { m_renderSize.x(), m_renderSize.y() } }, // VkRect2D renderArea; 1200 1u, // deUint32 clearValueCount; 1201 &attachmentClearValue // const VkClearValue* pClearValues; 1202 }; 1203 1204 const VkImageMemoryBarrier attachmentLayoutBarrier = 1205 { 1206 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; 1207 DE_NULL, // const void* pNext; 1208 0u, // VkAccessFlags srcAccessMask; 1209 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask; 1210 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout; 1211 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout; 1212 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex; 1213 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex; 1214 *m_colorImage, // VkImage image; 1215 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange; 1216 }; 1217 1218 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); 1219 1220 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo)); 1221 1222 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 1223 0u, DE_NULL, 0u, DE_NULL, 1u, &attachmentLayoutBarrier); 1224 1225 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); 1226 1227 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipeline); 1228 1229 std::vector<VkBuffer> vertexBuffers; 1230 for (size_t bufferNdx = 0; bufferNdx < m_vertexBuffers.size(); bufferNdx++) 1231 vertexBuffers.push_back(m_vertexBuffers[bufferNdx]); 1232 1233 if (vertexBuffers.size() <= 1) 1234 { 1235 // One vertex buffer 1236 vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, (deUint32)vertexBuffers.size(), vertexBuffers.data(), bindingOffsets.data()); 1237 } 1238 else 1239 { 1240 // Smoke-test vkCmdBindVertexBuffers(..., startBinding, ... ) 1241 1242 const deUint32 firstHalfLength = (deUint32)vertexBuffers.size() / 2; 1243 const deUint32 secondHalfLength = firstHalfLength + (deUint32)(vertexBuffers.size() % 2); 1244 1245 // Bind first half of vertex buffers 1246 vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, firstHalfLength, vertexBuffers.data(), bindingOffsets.data()); 1247 1248 // Bind second half of vertex buffers 1249 vk.cmdBindVertexBuffers(*m_cmdBuffer, firstHalfLength, secondHalfLength, 1250 vertexBuffers.data() + firstHalfLength, 1251 bindingOffsets.data() + firstHalfLength); 1252 } 1253 1254 vk.cmdDraw(*m_cmdBuffer, 4, 2, 0, 0); 1255 1256 vk.cmdEndRenderPass(*m_cmdBuffer); 1257 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer)); 1258 } 1259 1260 // Create fence 1261 m_fence = createFence(vk, vkDevice); 1262 } 1263 1264 VertexInputInstance::~VertexInputInstance (void) 1265 { 1266 const DeviceInterface& vk = m_context.getDeviceInterface(); 1267 const VkDevice vkDevice = m_context.getDevice(); 1268 1269 for (size_t bufferNdx = 0; bufferNdx < m_vertexBuffers.size(); bufferNdx++) 1270 vk.destroyBuffer(vkDevice, m_vertexBuffers[bufferNdx], DE_NULL); 1271 1272 for (size_t allocNdx = 0; allocNdx < m_vertexBufferAllocs.size(); allocNdx++) 1273 delete m_vertexBufferAllocs[allocNdx]; 1274 } 1275 1276 void VertexInputInstance::writeVertexInputData(deUint8* destPtr, const VkVertexInputBindingDescription& bindingDescription, const VkDeviceSize bindingOffset, const AttributeDescriptionList& attributes) 1277 { 1278 const deUint32 vertexCount = (bindingDescription.inputRate == VK_VERTEX_INPUT_RATE_VERTEX) ? (4 * 2) : 2; 1279 1280 deUint8* destOffsetPtr = ((deUint8 *)destPtr) + bindingOffset; 1281 for (deUint32 vertexNdx = 0; vertexNdx < vertexCount; vertexNdx++) 1282 { 1283 for (size_t attributeNdx = 0; attributeNdx < attributes.size(); attributeNdx++) 1284 { 1285 const VertexInputAttributeDescription& attribDesc = attributes[attributeNdx]; 1286 1287 // Only write vertex input data to bindings referenced by attribute descriptions 1288 if (attribDesc.vkDescription.binding == bindingDescription.binding) 1289 { 1290 writeVertexInputValue(destOffsetPtr + attribDesc.vkDescription.offset, attribDesc, vertexNdx); 1291 } 1292 } 1293 destOffsetPtr += bindingDescription.stride; 1294 } 1295 } 1296 1297 void writeVertexInputValueSint (deUint8* destPtr, VkFormat format, int componentNdx, deInt32 value) 1298 { 1299 const deUint32 componentSize = getVertexFormatComponentSize(format); 1300 deUint8* destFormatPtr = ((deUint8*)destPtr) + componentSize * componentNdx; 1301 1302 switch (componentSize) 1303 { 1304 case 1: 1305 *((deInt8*)destFormatPtr) = (deInt8)value; 1306 break; 1307 1308 case 2: 1309 *((deInt16*)destFormatPtr) = (deInt16)value; 1310 break; 1311 1312 case 4: 1313 *((deInt32*)destFormatPtr) = (deInt32)value; 1314 break; 1315 1316 default: 1317 DE_ASSERT(false); 1318 } 1319 } 1320 1321 void writeVertexInputValueUint (deUint8* destPtr, VkFormat format, int componentNdx, deUint32 value) 1322 { 1323 const deUint32 componentSize = getVertexFormatComponentSize(format); 1324 deUint8* destFormatPtr = ((deUint8*)destPtr) + componentSize * componentNdx; 1325 1326 switch (componentSize) 1327 { 1328 case 1: 1329 *((deUint8 *)destFormatPtr) = (deUint8)value; 1330 break; 1331 1332 case 2: 1333 *((deUint16 *)destFormatPtr) = (deUint16)value; 1334 break; 1335 1336 case 4: 1337 *((deUint32 *)destFormatPtr) = (deUint32)value; 1338 break; 1339 1340 default: 1341 DE_ASSERT(false); 1342 } 1343 } 1344 1345 void writeVertexInputValueSfloat (deUint8* destPtr, VkFormat format, int componentNdx, float value) 1346 { 1347 const deUint32 componentSize = getVertexFormatComponentSize(format); 1348 deUint8* destFormatPtr = ((deUint8*)destPtr) + componentSize * componentNdx; 1349 1350 switch (componentSize) 1351 { 1352 case 2: 1353 { 1354 deFloat16 f16 = deFloat32To16(value); 1355 deMemcpy(destFormatPtr, &f16, sizeof(f16)); 1356 break; 1357 } 1358 1359 case 4: 1360 deMemcpy(destFormatPtr, &value, sizeof(value)); 1361 break; 1362 1363 default: 1364 DE_ASSERT(false); 1365 } 1366 } 1367 1368 void VertexInputInstance::writeVertexInputValue (deUint8* destPtr, const VertexInputAttributeDescription& attribute, int indexId) 1369 { 1370 const int vertexInputCount = VertexInputTest::s_glslTypeDescriptions[attribute.glslType].vertexInputCount; 1371 const int componentCount = VertexInputTest::s_glslTypeDescriptions[attribute.glslType].vertexInputComponentCount; 1372 const deUint32 totalComponentCount = componentCount * vertexInputCount; 1373 const deUint32 vertexInputIndex = indexId * totalComponentCount + attribute.vertexInputIndex * componentCount; 1374 const bool hasBGROrder = isVertexFormatComponentOrderBGR(attribute.vkDescription.format); 1375 int swizzledNdx; 1376 1377 for (int componentNdx = 0; componentNdx < componentCount; componentNdx++) 1378 { 1379 if (hasBGROrder) 1380 { 1381 if (componentNdx == 0) 1382 swizzledNdx = 2; 1383 else if (componentNdx == 2) 1384 swizzledNdx = 0; 1385 else 1386 swizzledNdx = componentNdx; 1387 } 1388 else 1389 swizzledNdx = componentNdx; 1390 1391 switch (attribute.glslType) 1392 { 1393 case VertexInputTest::GLSL_TYPE_INT: 1394 case VertexInputTest::GLSL_TYPE_IVEC2: 1395 case VertexInputTest::GLSL_TYPE_IVEC3: 1396 case VertexInputTest::GLSL_TYPE_IVEC4: 1397 writeVertexInputValueSint(destPtr, attribute.vkDescription.format, componentNdx, -(deInt32)(vertexInputIndex + swizzledNdx)); 1398 break; 1399 1400 case VertexInputTest::GLSL_TYPE_UINT: 1401 case VertexInputTest::GLSL_TYPE_UVEC2: 1402 case VertexInputTest::GLSL_TYPE_UVEC3: 1403 case VertexInputTest::GLSL_TYPE_UVEC4: 1404 writeVertexInputValueUint(destPtr, attribute.vkDescription.format, componentNdx, vertexInputIndex + swizzledNdx); 1405 break; 1406 1407 case VertexInputTest::GLSL_TYPE_FLOAT: 1408 case VertexInputTest::GLSL_TYPE_VEC2: 1409 case VertexInputTest::GLSL_TYPE_VEC3: 1410 case VertexInputTest::GLSL_TYPE_VEC4: 1411 case VertexInputTest::GLSL_TYPE_MAT2: 1412 case VertexInputTest::GLSL_TYPE_MAT3: 1413 case VertexInputTest::GLSL_TYPE_MAT4: 1414 if (isVertexFormatSfloat(attribute.vkDescription.format)) 1415 { 1416 writeVertexInputValueSfloat(destPtr, attribute.vkDescription.format, componentNdx, -(0.01f * (float)(vertexInputIndex + swizzledNdx))); 1417 } 1418 else if (isVertexFormatSscaled(attribute.vkDescription.format)) 1419 { 1420 writeVertexInputValueSint(destPtr, attribute.vkDescription.format, componentNdx, -(deInt32)(vertexInputIndex + swizzledNdx)); 1421 } 1422 else if (isVertexFormatUscaled(attribute.vkDescription.format) || isVertexFormatUnorm(attribute.vkDescription.format) || isVertexFormatSRGB(attribute.vkDescription.format)) 1423 { 1424 writeVertexInputValueUint(destPtr, attribute.vkDescription.format, componentNdx, vertexInputIndex + swizzledNdx); 1425 } 1426 else if (isVertexFormatSnorm(attribute.vkDescription.format)) 1427 { 1428 const deInt32 minIntValue = -((1 << (getVertexFormatComponentSize(attribute.vkDescription.format) * 8 - 1))) + 1; 1429 writeVertexInputValueSint(destPtr, attribute.vkDescription.format, componentNdx, minIntValue + (vertexInputIndex + swizzledNdx)); 1430 } 1431 else 1432 DE_ASSERT(false); 1433 break; 1434 1435 case VertexInputTest::GLSL_TYPE_DOUBLE: 1436 case VertexInputTest::GLSL_TYPE_DVEC2: 1437 case VertexInputTest::GLSL_TYPE_DVEC3: 1438 case VertexInputTest::GLSL_TYPE_DVEC4: 1439 case VertexInputTest::GLSL_TYPE_DMAT2: 1440 case VertexInputTest::GLSL_TYPE_DMAT3: 1441 case VertexInputTest::GLSL_TYPE_DMAT4: 1442 *(reinterpret_cast<double *>(destPtr) + componentNdx) = -0.01 * (vertexInputIndex + swizzledNdx); 1443 1444 break; 1445 1446 default: 1447 DE_ASSERT(false); 1448 } 1449 } 1450 } 1451 1452 tcu::TestStatus VertexInputInstance::iterate (void) 1453 { 1454 const DeviceInterface& vk = m_context.getDeviceInterface(); 1455 const VkDevice vkDevice = m_context.getDevice(); 1456 const VkQueue queue = m_context.getUniversalQueue(); 1457 const VkSubmitInfo submitInfo = 1458 { 1459 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType; 1460 DE_NULL, // const void* pNext; 1461 0u, // deUint32 waitSemaphoreCount; 1462 DE_NULL, // const VkSemaphore* pWaitSemaphores; 1463 (const VkPipelineStageFlags*)DE_NULL, 1464 1u, // deUint32 commandBufferCount; 1465 &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers; 1466 0u, // deUint32 signalSemaphoreCount; 1467 DE_NULL // const VkSemaphore* pSignalSemaphores; 1468 }; 1469 1470 VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get())); 1471 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence)); 1472 VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/)); 1473 1474 return verifyImage(); 1475 } 1476 1477 bool VertexInputTest::isCompatibleType (VkFormat format, GlslType glslType) 1478 { 1479 const GlslTypeDescription glslTypeDesc = s_glslTypeDescriptions[glslType]; 1480 1481 if ((deUint32)s_glslTypeDescriptions[glslType].vertexInputComponentCount == getVertexFormatComponentCount(format)) 1482 { 1483 switch (glslTypeDesc.basicType) 1484 { 1485 case GLSL_BASIC_TYPE_INT: 1486 return isVertexFormatSint(format); 1487 1488 case GLSL_BASIC_TYPE_UINT: 1489 return isVertexFormatUint(format); 1490 1491 case GLSL_BASIC_TYPE_FLOAT: 1492 return getVertexFormatComponentSize(format) <= 4 && (isVertexFormatSfloat(format) || isVertexFormatSnorm(format) || isVertexFormatUnorm(format) || isVertexFormatSscaled(format) || isVertexFormatUscaled(format) || isVertexFormatSRGB(format)); 1493 1494 case GLSL_BASIC_TYPE_DOUBLE: 1495 return isVertexFormatSfloat(format) && getVertexFormatComponentSize(format) == 8; 1496 1497 default: 1498 DE_ASSERT(false); 1499 return false; 1500 } 1501 } 1502 else 1503 return false; 1504 } 1505 1506 tcu::TestStatus VertexInputInstance::verifyImage (void) 1507 { 1508 bool compareOk = false; 1509 const tcu::TextureFormat tcuColorFormat = mapVkFormat(m_colorFormat); 1510 tcu::TextureLevel reference (tcuColorFormat, m_renderSize.x(), m_renderSize.y()); 1511 const tcu::PixelBufferAccess refRedSubregion (tcu::getSubregion(reference.getAccess(), 1512 deRoundFloatToInt32((float)m_renderSize.x() * 0.0f), 1513 deRoundFloatToInt32((float)m_renderSize.y() * 0.0f), 1514 deRoundFloatToInt32((float)m_renderSize.x() * 0.5f), 1515 deRoundFloatToInt32((float)m_renderSize.y() * 1.0f))); 1516 const tcu::PixelBufferAccess refBlueSubregion (tcu::getSubregion(reference.getAccess(), 1517 deRoundFloatToInt32((float)m_renderSize.x() * 0.5f), 1518 deRoundFloatToInt32((float)m_renderSize.y() * 0.0f), 1519 deRoundFloatToInt32((float)m_renderSize.x() * 0.5f), 1520 deRoundFloatToInt32((float)m_renderSize.y() * 1.0f))); 1521 1522 // Create reference image 1523 tcu::clear(reference.getAccess(), defaultClearColor(tcuColorFormat)); 1524 tcu::clear(refRedSubregion, tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)); 1525 tcu::clear(refBlueSubregion, tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); 1526 1527 // Compare result with reference image 1528 { 1529 const DeviceInterface& vk = m_context.getDeviceInterface(); 1530 const VkDevice vkDevice = m_context.getDevice(); 1531 const VkQueue queue = m_context.getUniversalQueue(); 1532 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 1533 SimpleAllocator allocator (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice())); 1534 de::MovePtr<tcu::TextureLevel> result = readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_colorImage, m_colorFormat, m_renderSize); 1535 1536 compareOk = tcu::intThresholdPositionDeviationCompare(m_context.getTestContext().getLog(), 1537 "IntImageCompare", 1538 "Image comparison", 1539 reference.getAccess(), 1540 result->getAccess(), 1541 tcu::UVec4(2, 2, 2, 2), 1542 tcu::IVec3(1, 1, 0), 1543 true, 1544 tcu::COMPARE_LOG_RESULT); 1545 } 1546 1547 if (compareOk) 1548 return tcu::TestStatus::pass("Result image matches reference"); 1549 else 1550 return tcu::TestStatus::fail("Image mismatch"); 1551 } 1552 1553 std::string getAttributeInfoCaseName (const VertexInputTest::AttributeInfo& attributeInfo) 1554 { 1555 std::ostringstream caseName; 1556 const std::string formatName = getFormatName(attributeInfo.vkType); 1557 1558 caseName << "as_" << de::toLower(formatName.substr(10)) << "_rate_"; 1559 1560 if (attributeInfo.inputRate == VK_VERTEX_INPUT_RATE_VERTEX) 1561 caseName << "vertex"; 1562 else 1563 caseName << "instance"; 1564 1565 return caseName.str(); 1566 } 1567 1568 std::string getAttributeInfoDescription (const VertexInputTest::AttributeInfo& attributeInfo) 1569 { 1570 std::ostringstream caseDesc; 1571 1572 caseDesc << std::string(VertexInputTest::s_glslTypeDescriptions[attributeInfo.glslType].name) << " from type " << getFormatName(attributeInfo.vkType) << " with "; 1573 1574 if (attributeInfo.inputRate == VK_VERTEX_INPUT_RATE_VERTEX) 1575 caseDesc << "vertex input rate "; 1576 else 1577 caseDesc << "instance input rate "; 1578 1579 return caseDesc.str(); 1580 } 1581 1582 std::string getAttributeInfosDescription (const std::vector<VertexInputTest::AttributeInfo>& attributeInfos) 1583 { 1584 std::ostringstream caseDesc; 1585 1586 caseDesc << "Uses vertex attributes:\n"; 1587 1588 for (size_t attributeNdx = 0; attributeNdx < attributeInfos.size(); attributeNdx++) 1589 caseDesc << "\t- " << getAttributeInfoDescription (attributeInfos[attributeNdx]) << "\n"; 1590 1591 return caseDesc.str(); 1592 } 1593 1594 struct CompatibleFormats 1595 { 1596 VertexInputTest::GlslType glslType; 1597 std::vector<VkFormat> compatibleVkFormats; 1598 }; 1599 1600 void createSingleAttributeCases (tcu::TestCaseGroup* singleAttributeTests, VertexInputTest::GlslType glslType) 1601 { 1602 const VkFormat vertexFormats[] = 1603 { 1604 // Required, unpacked 1605 VK_FORMAT_R8_UNORM, 1606 VK_FORMAT_R8_SNORM, 1607 VK_FORMAT_R8_UINT, 1608 VK_FORMAT_R8_SINT, 1609 VK_FORMAT_R8G8_UNORM, 1610 VK_FORMAT_R8G8_SNORM, 1611 VK_FORMAT_R8G8_UINT, 1612 VK_FORMAT_R8G8_SINT, 1613 VK_FORMAT_R8G8B8A8_UNORM, 1614 VK_FORMAT_R8G8B8A8_SNORM, 1615 VK_FORMAT_R8G8B8A8_UINT, 1616 VK_FORMAT_R8G8B8A8_SINT, 1617 VK_FORMAT_B8G8R8A8_UNORM, 1618 VK_FORMAT_R16_UNORM, 1619 VK_FORMAT_R16_SNORM, 1620 VK_FORMAT_R16_UINT, 1621 VK_FORMAT_R16_SINT, 1622 VK_FORMAT_R16_SFLOAT, 1623 VK_FORMAT_R16G16_UNORM, 1624 VK_FORMAT_R16G16_SNORM, 1625 VK_FORMAT_R16G16_UINT, 1626 VK_FORMAT_R16G16_SINT, 1627 VK_FORMAT_R16G16_SFLOAT, 1628 VK_FORMAT_R16G16B16A16_UNORM, 1629 VK_FORMAT_R16G16B16A16_SNORM, 1630 VK_FORMAT_R16G16B16A16_UINT, 1631 VK_FORMAT_R16G16B16A16_SINT, 1632 VK_FORMAT_R16G16B16A16_SFLOAT, 1633 VK_FORMAT_R32_UINT, 1634 VK_FORMAT_R32_SINT, 1635 VK_FORMAT_R32_SFLOAT, 1636 VK_FORMAT_R32G32_UINT, 1637 VK_FORMAT_R32G32_SINT, 1638 VK_FORMAT_R32G32_SFLOAT, 1639 VK_FORMAT_R32G32B32_UINT, 1640 VK_FORMAT_R32G32B32_SINT, 1641 VK_FORMAT_R32G32B32_SFLOAT, 1642 VK_FORMAT_R32G32B32A32_UINT, 1643 VK_FORMAT_R32G32B32A32_SINT, 1644 VK_FORMAT_R32G32B32A32_SFLOAT, 1645 1646 // Scaled formats 1647 VK_FORMAT_R8G8_USCALED, 1648 VK_FORMAT_R8G8_SSCALED, 1649 VK_FORMAT_R16_USCALED, 1650 VK_FORMAT_R16_SSCALED, 1651 VK_FORMAT_R8G8B8_USCALED, 1652 VK_FORMAT_R8G8B8_SSCALED, 1653 VK_FORMAT_B8G8R8_USCALED, 1654 VK_FORMAT_B8G8R8_SSCALED, 1655 VK_FORMAT_R8G8B8A8_USCALED, 1656 VK_FORMAT_R8G8B8A8_SSCALED, 1657 VK_FORMAT_B8G8R8A8_USCALED, 1658 VK_FORMAT_B8G8R8A8_SSCALED, 1659 VK_FORMAT_R16G16_USCALED, 1660 VK_FORMAT_R16G16_SSCALED, 1661 VK_FORMAT_R16G16B16_USCALED, 1662 VK_FORMAT_R16G16B16_SSCALED, 1663 VK_FORMAT_R16G16B16A16_USCALED, 1664 VK_FORMAT_R16G16B16A16_SSCALED, 1665 1666 // SRGB formats 1667 VK_FORMAT_R8_SRGB, 1668 VK_FORMAT_R8G8_SRGB, 1669 VK_FORMAT_R8G8B8_SRGB, 1670 VK_FORMAT_B8G8R8_SRGB, 1671 VK_FORMAT_R8G8B8A8_SRGB, 1672 VK_FORMAT_B8G8R8A8_SRGB, 1673 1674 // Double formats 1675 VK_FORMAT_R64_SFLOAT, 1676 VK_FORMAT_R64G64_SFLOAT, 1677 VK_FORMAT_R64G64B64_SFLOAT, 1678 VK_FORMAT_R64G64B64A64_SFLOAT, 1679 }; 1680 1681 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(vertexFormats); formatNdx++) 1682 { 1683 if (VertexInputTest::isCompatibleType(vertexFormats[formatNdx], glslType)) 1684 { 1685 // Create test case for RATE_VERTEX 1686 VertexInputTest::AttributeInfo attributeInfo; 1687 attributeInfo.vkType = vertexFormats[formatNdx]; 1688 attributeInfo.glslType = glslType; 1689 attributeInfo.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; 1690 1691 singleAttributeTests->addChild(new VertexInputTest(singleAttributeTests->getTestContext(), 1692 getAttributeInfoCaseName(attributeInfo), 1693 getAttributeInfoDescription(attributeInfo), 1694 std::vector<VertexInputTest::AttributeInfo>(1, attributeInfo), 1695 VertexInputTest::BINDING_MAPPING_ONE_TO_ONE, 1696 VertexInputTest::ATTRIBUTE_LAYOUT_INTERLEAVED)); 1697 1698 // Create test case for RATE_INSTANCE 1699 attributeInfo.inputRate = VK_VERTEX_INPUT_RATE_INSTANCE; 1700 1701 singleAttributeTests->addChild(new VertexInputTest(singleAttributeTests->getTestContext(), 1702 getAttributeInfoCaseName(attributeInfo), 1703 getAttributeInfoDescription(attributeInfo), 1704 std::vector<VertexInputTest::AttributeInfo>(1, attributeInfo), 1705 VertexInputTest::BINDING_MAPPING_ONE_TO_ONE, 1706 VertexInputTest::ATTRIBUTE_LAYOUT_INTERLEAVED)); 1707 } 1708 } 1709 } 1710 1711 void createSingleAttributeTests (tcu::TestCaseGroup* singleAttributeTests) 1712 { 1713 for (int glslTypeNdx = 0; glslTypeNdx < VertexInputTest::GLSL_TYPE_COUNT; glslTypeNdx++) 1714 { 1715 VertexInputTest::GlslType glslType = (VertexInputTest::GlslType)glslTypeNdx; 1716 addTestGroup(singleAttributeTests, VertexInputTest::s_glslTypeDescriptions[glslType].name, "", createSingleAttributeCases, glslType); 1717 } 1718 } 1719 1720 // Create all unique GlslType combinations recursively 1721 void createMultipleAttributeCases (deUint32 depth, deUint32 firstNdx, CompatibleFormats* compatibleFormats, de::Random& randomFunc, tcu::TestCaseGroup& testGroup, VertexInputTest::BindingMapping bindingMapping, VertexInputTest::AttributeLayout attributeLayout, const std::vector<VertexInputTest::AttributeInfo>& attributeInfos = std::vector<VertexInputTest::AttributeInfo>(0)) 1722 { 1723 tcu::TestContext& testCtx = testGroup.getTestContext(); 1724 1725 // Exclude double values, which are not included in vertexFormats 1726 for (deUint32 currentNdx = firstNdx; currentNdx < VertexInputTest::GLSL_TYPE_DOUBLE - depth; currentNdx++) 1727 { 1728 std::vector <VertexInputTest::AttributeInfo> newAttributeInfos = attributeInfos; 1729 1730 { 1731 VertexInputTest::AttributeInfo attributeInfo; 1732 attributeInfo.glslType = (VertexInputTest::GlslType)currentNdx; 1733 attributeInfo.inputRate = (depth % 2 == 0) ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE; 1734 attributeInfo.vkType = VK_FORMAT_UNDEFINED; 1735 1736 newAttributeInfos.push_back(attributeInfo); 1737 } 1738 1739 // Add test case 1740 if (depth == 0) 1741 { 1742 // Select a random compatible format for each attribute 1743 for (size_t i = 0; i < newAttributeInfos.size(); i++) 1744 { 1745 const std::vector<VkFormat>& formats = compatibleFormats[newAttributeInfos[i].glslType].compatibleVkFormats; 1746 newAttributeInfos[i].vkType = formats[randomFunc.getUint32() % formats.size()]; 1747 } 1748 1749 const std::string caseName = VertexInputTest::s_glslTypeDescriptions[currentNdx].name; 1750 const std::string caseDesc = getAttributeInfosDescription(newAttributeInfos); 1751 1752 testGroup.addChild(new VertexInputTest(testCtx, caseName, caseDesc, newAttributeInfos, bindingMapping, attributeLayout)); 1753 } 1754 // Add test group 1755 else 1756 { 1757 const std::string name = VertexInputTest::s_glslTypeDescriptions[currentNdx].name; 1758 de::MovePtr<tcu::TestCaseGroup> newTestGroup (new tcu::TestCaseGroup(testCtx, name.c_str(), "")); 1759 1760 createMultipleAttributeCases(depth - 1u, currentNdx + 1u, compatibleFormats, randomFunc, *newTestGroup, bindingMapping, attributeLayout, newAttributeInfos); 1761 testGroup.addChild(newTestGroup.release()); 1762 } 1763 } 1764 } 1765 1766 void createMultipleAttributeTests (tcu::TestCaseGroup* multipleAttributeTests) 1767 { 1768 // Required vertex formats, unpacked 1769 const VkFormat vertexFormats[] = 1770 { 1771 VK_FORMAT_R8_UNORM, 1772 VK_FORMAT_R8_SNORM, 1773 VK_FORMAT_R8_UINT, 1774 VK_FORMAT_R8_SINT, 1775 VK_FORMAT_R8G8_UNORM, 1776 VK_FORMAT_R8G8_SNORM, 1777 VK_FORMAT_R8G8_UINT, 1778 VK_FORMAT_R8G8_SINT, 1779 VK_FORMAT_R8G8B8A8_UNORM, 1780 VK_FORMAT_R8G8B8A8_SNORM, 1781 VK_FORMAT_R8G8B8A8_UINT, 1782 VK_FORMAT_R8G8B8A8_SINT, 1783 VK_FORMAT_B8G8R8A8_UNORM, 1784 VK_FORMAT_R16_UNORM, 1785 VK_FORMAT_R16_SNORM, 1786 VK_FORMAT_R16_UINT, 1787 VK_FORMAT_R16_SINT, 1788 VK_FORMAT_R16_SFLOAT, 1789 VK_FORMAT_R16G16_UNORM, 1790 VK_FORMAT_R16G16_SNORM, 1791 VK_FORMAT_R16G16_UINT, 1792 VK_FORMAT_R16G16_SINT, 1793 VK_FORMAT_R16G16_SFLOAT, 1794 VK_FORMAT_R16G16B16A16_UNORM, 1795 VK_FORMAT_R16G16B16A16_SNORM, 1796 VK_FORMAT_R16G16B16A16_UINT, 1797 VK_FORMAT_R16G16B16A16_SINT, 1798 VK_FORMAT_R16G16B16A16_SFLOAT, 1799 VK_FORMAT_R32_UINT, 1800 VK_FORMAT_R32_SINT, 1801 VK_FORMAT_R32_SFLOAT, 1802 VK_FORMAT_R32G32_UINT, 1803 VK_FORMAT_R32G32_SINT, 1804 VK_FORMAT_R32G32_SFLOAT, 1805 VK_FORMAT_R32G32B32_UINT, 1806 VK_FORMAT_R32G32B32_SINT, 1807 VK_FORMAT_R32G32B32_SFLOAT, 1808 VK_FORMAT_R32G32B32A32_UINT, 1809 VK_FORMAT_R32G32B32A32_SINT, 1810 VK_FORMAT_R32G32B32A32_SFLOAT 1811 }; 1812 1813 // Find compatible VK formats for each GLSL vertex type 1814 CompatibleFormats compatibleFormats[VertexInputTest::GLSL_TYPE_COUNT]; 1815 { 1816 for (int glslTypeNdx = 0; glslTypeNdx < VertexInputTest::GLSL_TYPE_COUNT; glslTypeNdx++) 1817 { 1818 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(vertexFormats); formatNdx++) 1819 { 1820 if (VertexInputTest::isCompatibleType(vertexFormats[formatNdx], (VertexInputTest::GlslType)glslTypeNdx)) 1821 compatibleFormats[glslTypeNdx].compatibleVkFormats.push_back(vertexFormats[formatNdx]); 1822 } 1823 } 1824 } 1825 1826 de::Random randomFunc(102030); 1827 tcu::TestContext& testCtx = multipleAttributeTests->getTestContext(); 1828 de::MovePtr<tcu::TestCaseGroup> oneToOneAttributeTests(new tcu::TestCaseGroup(testCtx, "attributes", "")); 1829 de::MovePtr<tcu::TestCaseGroup> oneToManyAttributeTests(new tcu::TestCaseGroup(testCtx, "attributes", "")); 1830 de::MovePtr<tcu::TestCaseGroup> oneToManySequentialAttributeTests(new tcu::TestCaseGroup(testCtx, "attributes_sequential", "")); 1831 1832 createMultipleAttributeCases(2u, 0u, compatibleFormats, randomFunc, *oneToOneAttributeTests, VertexInputTest::BINDING_MAPPING_ONE_TO_ONE, VertexInputTest::ATTRIBUTE_LAYOUT_INTERLEAVED); 1833 createMultipleAttributeCases(2u, 0u, compatibleFormats, randomFunc, *oneToManyAttributeTests, VertexInputTest::BINDING_MAPPING_ONE_TO_MANY, VertexInputTest::ATTRIBUTE_LAYOUT_INTERLEAVED); 1834 createMultipleAttributeCases(2u, 0u, compatibleFormats, randomFunc, *oneToManySequentialAttributeTests, VertexInputTest::BINDING_MAPPING_ONE_TO_MANY, VertexInputTest::ATTRIBUTE_LAYOUT_SEQUENTIAL); 1835 1836 de::MovePtr<tcu::TestCaseGroup> bindingOneToOneTests(new tcu::TestCaseGroup(testCtx, "binding_one_to_one", "Each attribute uses a unique binding")); 1837 bindingOneToOneTests->addChild(oneToOneAttributeTests.release()); 1838 multipleAttributeTests->addChild(bindingOneToOneTests.release()); 1839 1840 de::MovePtr<tcu::TestCaseGroup> bindingOneToManyTests(new tcu::TestCaseGroup(testCtx, "binding_one_to_many", "Attributes share the same binding")); 1841 bindingOneToManyTests->addChild(oneToManyAttributeTests.release()); 1842 bindingOneToManyTests->addChild(oneToManySequentialAttributeTests.release()); 1843 multipleAttributeTests->addChild(bindingOneToManyTests.release()); 1844 } 1845 1846 void createMaxAttributeTests (tcu::TestCaseGroup* maxAttributeTests) 1847 { 1848 // Required vertex formats, unpacked 1849 const VkFormat vertexFormats[] = 1850 { 1851 VK_FORMAT_R8_UNORM, 1852 VK_FORMAT_R8_SNORM, 1853 VK_FORMAT_R8_UINT, 1854 VK_FORMAT_R8_SINT, 1855 VK_FORMAT_R8G8_UNORM, 1856 VK_FORMAT_R8G8_SNORM, 1857 VK_FORMAT_R8G8_UINT, 1858 VK_FORMAT_R8G8_SINT, 1859 VK_FORMAT_R8G8B8A8_UNORM, 1860 VK_FORMAT_R8G8B8A8_SNORM, 1861 VK_FORMAT_R8G8B8A8_UINT, 1862 VK_FORMAT_R8G8B8A8_SINT, 1863 VK_FORMAT_B8G8R8A8_UNORM, 1864 VK_FORMAT_R16_UNORM, 1865 VK_FORMAT_R16_SNORM, 1866 VK_FORMAT_R16_UINT, 1867 VK_FORMAT_R16_SINT, 1868 VK_FORMAT_R16_SFLOAT, 1869 VK_FORMAT_R16G16_UNORM, 1870 VK_FORMAT_R16G16_SNORM, 1871 VK_FORMAT_R16G16_UINT, 1872 VK_FORMAT_R16G16_SINT, 1873 VK_FORMAT_R16G16_SFLOAT, 1874 VK_FORMAT_R16G16B16A16_UNORM, 1875 VK_FORMAT_R16G16B16A16_SNORM, 1876 VK_FORMAT_R16G16B16A16_UINT, 1877 VK_FORMAT_R16G16B16A16_SINT, 1878 VK_FORMAT_R16G16B16A16_SFLOAT, 1879 VK_FORMAT_R32_UINT, 1880 VK_FORMAT_R32_SINT, 1881 VK_FORMAT_R32_SFLOAT, 1882 VK_FORMAT_R32G32_UINT, 1883 VK_FORMAT_R32G32_SINT, 1884 VK_FORMAT_R32G32_SFLOAT, 1885 VK_FORMAT_R32G32B32_UINT, 1886 VK_FORMAT_R32G32B32_SINT, 1887 VK_FORMAT_R32G32B32_SFLOAT, 1888 VK_FORMAT_R32G32B32A32_UINT, 1889 VK_FORMAT_R32G32B32A32_SINT, 1890 VK_FORMAT_R32G32B32A32_SFLOAT 1891 }; 1892 1893 // VkPhysicalDeviceLimits::maxVertexInputAttributes is used when attributeCount is 0 1894 const deUint32 attributeCount[] = { 16, 32, 64, 128, 0 }; 1895 tcu::TestContext& testCtx (maxAttributeTests->getTestContext()); 1896 de::Random randomFunc (132030); 1897 1898 // Find compatible VK formats for each GLSL vertex type 1899 CompatibleFormats compatibleFormats[VertexInputTest::GLSL_TYPE_COUNT]; 1900 { 1901 for (int glslTypeNdx = 0; glslTypeNdx < VertexInputTest::GLSL_TYPE_COUNT; glslTypeNdx++) 1902 { 1903 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(vertexFormats); formatNdx++) 1904 { 1905 if (VertexInputTest::isCompatibleType(vertexFormats[formatNdx], (VertexInputTest::GlslType)glslTypeNdx)) 1906 compatibleFormats[glslTypeNdx].compatibleVkFormats.push_back(vertexFormats[formatNdx]); 1907 } 1908 } 1909 } 1910 1911 for (deUint32 attributeCountNdx = 0; attributeCountNdx < DE_LENGTH_OF_ARRAY(attributeCount); attributeCountNdx++) 1912 { 1913 const std::string groupName = (attributeCount[attributeCountNdx] == 0 ? "query_max" : de::toString(attributeCount[attributeCountNdx])) + "_attributes"; 1914 const std::string groupDesc = de::toString(attributeCount[attributeCountNdx]) + " vertex input attributes"; 1915 1916 de::MovePtr<tcu::TestCaseGroup> numAttributeTests(new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupDesc.c_str())); 1917 de::MovePtr<tcu::TestCaseGroup> bindingOneToOneTests(new tcu::TestCaseGroup(testCtx, "binding_one_to_one", "Each attribute uses a unique binding")); 1918 de::MovePtr<tcu::TestCaseGroup> bindingOneToManyTests(new tcu::TestCaseGroup(testCtx, "binding_one_to_many", "Attributes share the same binding")); 1919 1920 std::vector<VertexInputTest::AttributeInfo> attributeInfos(attributeCount[attributeCountNdx]); 1921 1922 for (deUint32 attributeNdx = 0; attributeNdx < attributeCount[attributeCountNdx]; attributeNdx++) 1923 { 1924 // Use random glslTypes, each consuming one attribute location 1925 const VertexInputTest::GlslType glslType = (VertexInputTest::GlslType)(randomFunc.getUint32() % VertexInputTest::GLSL_TYPE_MAT2); 1926 const std::vector<VkFormat>& formats = compatibleFormats[glslType].compatibleVkFormats; 1927 const VkFormat format = formats[randomFunc.getUint32() % formats.size()]; 1928 1929 attributeInfos[attributeNdx].glslType = glslType; 1930 attributeInfos[attributeNdx].inputRate = ((attributeCountNdx + attributeNdx) % 2 == 0) ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE; 1931 attributeInfos[attributeNdx].vkType = format; 1932 } 1933 1934 bindingOneToOneTests->addChild(new VertexInputTest(testCtx, "interleaved", "Interleaved attribute layout", attributeInfos, VertexInputTest::BINDING_MAPPING_ONE_TO_ONE, VertexInputTest::ATTRIBUTE_LAYOUT_INTERLEAVED)); 1935 bindingOneToManyTests->addChild(new VertexInputTest(testCtx, "interleaved", "Interleaved attribute layout", attributeInfos, VertexInputTest::BINDING_MAPPING_ONE_TO_MANY, VertexInputTest::ATTRIBUTE_LAYOUT_INTERLEAVED)); 1936 bindingOneToManyTests->addChild(new VertexInputTest(testCtx, "sequential", "Sequential attribute layout", attributeInfos, VertexInputTest::BINDING_MAPPING_ONE_TO_MANY, VertexInputTest::ATTRIBUTE_LAYOUT_SEQUENTIAL)); 1937 1938 numAttributeTests->addChild(bindingOneToOneTests.release()); 1939 numAttributeTests->addChild(bindingOneToManyTests.release()); 1940 maxAttributeTests->addChild(numAttributeTests.release()); 1941 } 1942 } 1943 1944 } // anonymous 1945 1946 void createVertexInputTests (tcu::TestCaseGroup* vertexInputTests) 1947 { 1948 addTestGroup(vertexInputTests, "single_attribute", "Uses one attribute", createSingleAttributeTests); 1949 addTestGroup(vertexInputTests, "multiple_attributes", "Uses more than one attribute", createMultipleAttributeTests); 1950 addTestGroup(vertexInputTests, "max_attributes", "Implementations can use as many vertex input attributes as they advertise", createMaxAttributeTests); 1951 } 1952 1953 } // pipeline 1954 } // vkt 1955
