1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2015 The Khronos Group Inc. 6 * Copyright (c) 2015 Samsung Electronics Co., Ltd. 7 * Copyright (c) 2016 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief Vulkan ShaderExecutor 24 *//*--------------------------------------------------------------------*/ 25 26 #include "vktShaderExecutor.hpp" 27 28 #include "vkMemUtil.hpp" 29 #include "vkRef.hpp" 30 #include "vkPrograms.hpp" 31 #include "vkRefUtil.hpp" 32 #include "vkTypeUtil.hpp" 33 #include "vkQueryUtil.hpp" 34 #include "vkBuilderUtil.hpp" 35 36 #include "gluShaderUtil.hpp" 37 38 #include "tcuVector.hpp" 39 #include "tcuTestLog.hpp" 40 #include "tcuTextureUtil.hpp" 41 42 #include "deUniquePtr.hpp" 43 #include "deStringUtil.hpp" 44 #include "deSharedPtr.hpp" 45 46 #include <map> 47 #include <sstream> 48 #include <iostream> 49 50 using std::vector; 51 using namespace vk; 52 53 namespace vkt 54 { 55 namespace shaderexecutor 56 { 57 namespace 58 { 59 60 enum 61 { 62 DEFAULT_RENDER_WIDTH = 100, 63 DEFAULT_RENDER_HEIGHT = 100, 64 }; 65 66 // Common typedefs 67 68 typedef de::SharedPtr<Unique<VkImage> > VkImageSp; 69 typedef de::SharedPtr<Unique<VkImageView> > VkImageViewSp; 70 typedef de::SharedPtr<Unique<VkBuffer> > VkBufferSp; 71 typedef de::SharedPtr<Allocation> AllocationSp; 72 73 // Shader utilities 74 75 static VkClearValue getDefaultClearColor (void) 76 { 77 return makeClearValueColorF32(0.125f, 0.25f, 0.5f, 1.0f); 78 } 79 80 static std::string generateEmptyFragmentSource (void) 81 { 82 std::ostringstream src; 83 84 src << "#version 310 es\n" 85 "layout(location=0) out highp vec4 o_color;\n"; 86 87 src << "void main (void)\n{\n"; 88 src << " o_color = vec4(0.0);\n"; 89 src << "}\n"; 90 91 return src.str(); 92 } 93 94 static std::string generatePassthroughVertexShader (const std::vector<Symbol>& inputs, const char* inputPrefix, const char* outputPrefix) 95 { 96 97 std::ostringstream src; 98 int location = 0; 99 100 src << "#version 310 es\n" 101 "layout(location = " << location << ") in highp vec4 a_position;\n"; 102 103 for (vector<Symbol>::const_iterator input = inputs.begin(); input != inputs.end(); ++input) 104 { 105 location++; 106 src << "layout(location = "<< location << ") in " << glu::declare(input->varType, inputPrefix + input->name) << ";\n" 107 << "layout(location = " << location - 1 << ") flat out " << glu::declare(input->varType, outputPrefix + input->name) << ";\n"; 108 } 109 110 src << "\nvoid main (void)\n{\n" 111 << " gl_Position = a_position;\n" 112 << " gl_PointSize = 1.0;\n"; 113 114 for (vector<Symbol>::const_iterator input = inputs.begin(); input != inputs.end(); ++input) 115 src << "\t" << outputPrefix << input->name << " = " << inputPrefix << input->name << ";\n"; 116 117 src << "}\n"; 118 119 return src.str(); 120 } 121 122 static std::string generateVertexShader (const ShaderSpec& shaderSpec, const std::string& inputPrefix, const std::string& outputPrefix) 123 { 124 DE_ASSERT(!inputPrefix.empty() && !outputPrefix.empty()); 125 126 std::ostringstream src; 127 128 src << glu::getGLSLVersionDeclaration(shaderSpec.glslVersion) << "\n"; 129 130 if (!shaderSpec.globalDeclarations.empty()) 131 src << shaderSpec.globalDeclarations << "\n"; 132 133 src << "layout(location = 0) in highp vec4 a_position;\n"; 134 135 int locationNumber = 1; 136 for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input, ++locationNumber) 137 src << "layout(location = " << locationNumber << ") in " << glu::declare(input->varType, inputPrefix + input->name) << ";\n"; 138 139 locationNumber = 0; 140 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output, ++locationNumber) 141 { 142 DE_ASSERT(output->varType.isBasicType()); 143 144 if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType())) 145 { 146 const int vecSize = glu::getDataTypeScalarSize(output->varType.getBasicType()); 147 const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT; 148 const glu::VarType intType (intBaseType, glu::PRECISION_HIGHP); 149 150 src << "layout(location = " << locationNumber << ") flat out " << glu::declare(intType, outputPrefix + output->name) << ";\n"; 151 } 152 else 153 src << "layout(location = " << locationNumber << ") flat out " << glu::declare(output->varType, outputPrefix + output->name) << ";\n"; 154 } 155 156 src << "\n" 157 << "void main (void)\n" 158 << "{\n" 159 << " gl_Position = a_position;\n" 160 << " gl_PointSize = 1.0;\n"; 161 162 // Declare & fetch local input variables 163 for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input) 164 src << "\t" << glu::declare(input->varType, input->name) << " = " << inputPrefix << input->name << ";\n"; 165 166 // Declare local output variables 167 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output) 168 src << "\t" << glu::declare(output->varType, output->name) << ";\n"; 169 170 // Operation - indented to correct level. 171 { 172 std::istringstream opSrc (shaderSpec.source); 173 std::string line; 174 175 while (std::getline(opSrc, line)) 176 src << "\t" << line << "\n"; 177 } 178 179 // Assignments to outputs. 180 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output) 181 { 182 if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType())) 183 { 184 const int vecSize = glu::getDataTypeScalarSize(output->varType.getBasicType()); 185 const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT; 186 187 src << "\t" << outputPrefix << output->name << " = " << glu::getDataTypeName(intBaseType) << "(" << output->name << ");\n"; 188 } 189 else 190 src << "\t" << outputPrefix << output->name << " = " << output->name << ";\n"; 191 } 192 193 src << "}\n"; 194 195 return src.str(); 196 } 197 198 struct FragmentOutputLayout 199 { 200 std::vector<const Symbol*> locationSymbols; //! Symbols by location 201 std::map<std::string, int> locationMap; //! Map from symbol name to start location 202 }; 203 204 static void generateFragShaderOutputDecl (std::ostream& src, const ShaderSpec& shaderSpec, bool useIntOutputs, const std::map<std::string, int>& outLocationMap, const std::string& outputPrefix) 205 { 206 for (int outNdx = 0; outNdx < (int)shaderSpec.outputs.size(); ++outNdx) 207 { 208 const Symbol& output = shaderSpec.outputs[outNdx]; 209 const int location = de::lookup(outLocationMap, output.name); 210 const std::string outVarName = outputPrefix + output.name; 211 glu::VariableDeclaration decl (output.varType, outVarName, glu::STORAGE_OUT, glu::INTERPOLATION_LAST, glu::Layout(location)); 212 213 TCU_CHECK_INTERNAL(output.varType.isBasicType()); 214 215 if (useIntOutputs && glu::isDataTypeFloatOrVec(output.varType.getBasicType())) 216 { 217 const int vecSize = glu::getDataTypeScalarSize(output.varType.getBasicType()); 218 const glu::DataType uintBasicType = vecSize > 1 ? glu::getDataTypeUintVec(vecSize) : glu::TYPE_UINT; 219 const glu::VarType uintType (uintBasicType, glu::PRECISION_HIGHP); 220 221 decl.varType = uintType; 222 src << decl << ";\n"; 223 } 224 else if (glu::isDataTypeBoolOrBVec(output.varType.getBasicType())) 225 { 226 const int vecSize = glu::getDataTypeScalarSize(output.varType.getBasicType()); 227 const glu::DataType intBasicType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT; 228 const glu::VarType intType (intBasicType, glu::PRECISION_HIGHP); 229 230 decl.varType = intType; 231 src << decl << ";\n"; 232 } 233 else if (glu::isDataTypeMatrix(output.varType.getBasicType())) 234 { 235 const int vecSize = glu::getDataTypeMatrixNumRows(output.varType.getBasicType()); 236 const int numVecs = glu::getDataTypeMatrixNumColumns(output.varType.getBasicType()); 237 const glu::DataType uintBasicType = glu::getDataTypeUintVec(vecSize); 238 const glu::VarType uintType (uintBasicType, glu::PRECISION_HIGHP); 239 240 decl.varType = uintType; 241 for (int vecNdx = 0; vecNdx < numVecs; ++vecNdx) 242 { 243 decl.name = outVarName + "_" + de::toString(vecNdx); 244 decl.layout.location = location + vecNdx; 245 src << decl << ";\n"; 246 } 247 } 248 else 249 src << decl << ";\n"; 250 } 251 } 252 253 static void generateFragShaderOutAssign (std::ostream& src, const ShaderSpec& shaderSpec, bool useIntOutputs, const std::string& valuePrefix, const std::string& outputPrefix) 254 { 255 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output) 256 { 257 if (useIntOutputs && glu::isDataTypeFloatOrVec(output->varType.getBasicType())) 258 src << " o_" << output->name << " = floatBitsToUint(" << valuePrefix << output->name << ");\n"; 259 else if (glu::isDataTypeMatrix(output->varType.getBasicType())) 260 { 261 const int numVecs = glu::getDataTypeMatrixNumColumns(output->varType.getBasicType()); 262 263 for (int vecNdx = 0; vecNdx < numVecs; ++vecNdx) 264 if (useIntOutputs) 265 src << "\t" << outputPrefix << output->name << "_" << vecNdx << " = floatBitsToUint(" << valuePrefix << output->name << "[" << vecNdx << "]);\n"; 266 else 267 src << "\t" << outputPrefix << output->name << "_" << vecNdx << " = " << valuePrefix << output->name << "[" << vecNdx << "];\n"; 268 } 269 else if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType())) 270 { 271 const int vecSize = glu::getDataTypeScalarSize(output->varType.getBasicType()); 272 const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT; 273 274 src << "\t" << outputPrefix << output->name << " = " << glu::getDataTypeName(intBaseType) << "(" << valuePrefix << output->name << ");\n"; 275 } 276 else 277 src << "\t" << outputPrefix << output->name << " = " << valuePrefix << output->name << ";\n"; 278 } 279 } 280 281 static std::string generatePassthroughFragmentShader (const ShaderSpec& shaderSpec, bool useIntOutputs, const std::map<std::string, int>& outLocationMap, const std::string& inputPrefix, const std::string& outputPrefix) 282 { 283 std::ostringstream src; 284 285 src <<"#version 310 es\n"; 286 287 if (!shaderSpec.globalDeclarations.empty()) 288 src << shaderSpec.globalDeclarations << "\n"; 289 290 int locationNumber = 0; 291 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output, ++locationNumber) 292 { 293 if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType())) 294 { 295 const int vecSize = glu::getDataTypeScalarSize(output->varType.getBasicType()); 296 const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT; 297 const glu::VarType intType (intBaseType, glu::PRECISION_HIGHP); 298 299 src << "layout(location = " << locationNumber << ") flat in " << glu::declare(intType, inputPrefix + output->name) << ";\n"; 300 } 301 else 302 src << "layout(location = " << locationNumber << ") flat in " << glu::declare(output->varType, inputPrefix + output->name) << ";\n"; 303 } 304 305 generateFragShaderOutputDecl(src, shaderSpec, useIntOutputs, outLocationMap, outputPrefix); 306 307 src << "\nvoid main (void)\n{\n"; 308 309 generateFragShaderOutAssign(src, shaderSpec, useIntOutputs, inputPrefix, outputPrefix); 310 311 src << "}\n"; 312 313 return src.str(); 314 } 315 316 static std::string generateGeometryShader (const ShaderSpec& shaderSpec, const std::string& inputPrefix, const std::string& outputPrefix) 317 { 318 DE_ASSERT(!inputPrefix.empty() && !outputPrefix.empty()); 319 320 std::ostringstream src; 321 322 src << glu::getGLSLVersionDeclaration(shaderSpec.glslVersion) << "\n"; 323 324 if (shaderSpec.glslVersion == glu::GLSL_VERSION_310_ES) 325 src << "#extension GL_EXT_geometry_shader : require\n"; 326 327 if (!shaderSpec.globalDeclarations.empty()) 328 src << shaderSpec.globalDeclarations << "\n"; 329 330 src << "layout(points) in;\n" 331 << "layout(points, max_vertices = 1) out;\n"; 332 333 int locationNumber = 0; 334 for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input, ++locationNumber) 335 src << "layout(location = " << locationNumber << ") flat in " << glu::declare(input->varType, inputPrefix + input->name) << "[];\n"; 336 337 locationNumber = 0; 338 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output, ++locationNumber) 339 { 340 DE_ASSERT(output->varType.isBasicType()); 341 342 if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType())) 343 { 344 const int vecSize = glu::getDataTypeScalarSize(output->varType.getBasicType()); 345 const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT; 346 const glu::VarType intType (intBaseType, glu::PRECISION_HIGHP); 347 348 src << "layout(location = " << locationNumber << ") flat out " << glu::declare(intType, outputPrefix + output->name) << ";\n"; 349 } 350 else 351 src << "layout(location = " << locationNumber << ") flat out " << glu::declare(output->varType, outputPrefix + output->name) << ";\n"; 352 } 353 354 src << "\n" 355 << "void main (void)\n" 356 << "{\n" 357 << " gl_Position = gl_in[0].gl_Position;\n\n"; 358 359 // Fetch input variables 360 for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input) 361 src << "\t" << glu::declare(input->varType, input->name) << " = " << inputPrefix << input->name << "[0];\n"; 362 363 // Declare local output variables. 364 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output) 365 src << "\t" << glu::declare(output->varType, output->name) << ";\n"; 366 367 src << "\n"; 368 369 // Operation - indented to correct level. 370 { 371 std::istringstream opSrc (shaderSpec.source); 372 std::string line; 373 374 while (std::getline(opSrc, line)) 375 src << "\t" << line << "\n"; 376 } 377 378 // Assignments to outputs. 379 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output) 380 { 381 if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType())) 382 { 383 const int vecSize = glu::getDataTypeScalarSize(output->varType.getBasicType()); 384 const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT; 385 386 src << "\t" << outputPrefix << output->name << " = " << glu::getDataTypeName(intBaseType) << "(" << output->name << ");\n"; 387 } 388 else 389 src << "\t" << outputPrefix << output->name << " = " << output->name << ";\n"; 390 } 391 392 src << " EmitVertex();\n" 393 << " EndPrimitive();\n" 394 << "}\n"; 395 396 return src.str(); 397 } 398 399 static std::string generateFragmentShader (const ShaderSpec& shaderSpec, bool useIntOutputs, const std::map<std::string, int>& outLocationMap, const std::string& inputPrefix, const std::string& outputPrefix) 400 { 401 std::ostringstream src; 402 src << glu::getGLSLVersionDeclaration(shaderSpec.glslVersion) << "\n"; 403 if (!shaderSpec.globalDeclarations.empty()) 404 src << shaderSpec.globalDeclarations << "\n"; 405 406 int locationNumber = 0; 407 for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input, ++locationNumber) 408 src << "layout(location = " << locationNumber << ") flat in " << glu::declare(input->varType, inputPrefix + input->name) << ";\n"; 409 410 generateFragShaderOutputDecl(src, shaderSpec, useIntOutputs, outLocationMap, outputPrefix); 411 412 src << "\nvoid main (void)\n{\n"; 413 414 // Declare & fetch local input variables 415 for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input) 416 src << "\t" << glu::declare(input->varType, input->name) << " = " << inputPrefix << input->name << ";\n"; 417 418 // Declare output variables 419 for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end(); ++output) 420 src << "\t" << glu::declare(output->varType, output->name) << ";\n"; 421 422 // Operation - indented to correct level. 423 { 424 std::istringstream opSrc (shaderSpec.source); 425 std::string line; 426 427 while (std::getline(opSrc, line)) 428 src << "\t" << line << "\n"; 429 } 430 431 generateFragShaderOutAssign(src, shaderSpec, useIntOutputs, "", outputPrefix); 432 433 src << "}\n"; 434 435 return src.str(); 436 } 437 438 // FragmentOutExecutor 439 440 class FragmentOutExecutor : public ShaderExecutor 441 { 442 public: 443 FragmentOutExecutor (Context& context, glu::ShaderType shaderType, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout); 444 virtual ~FragmentOutExecutor (void); 445 446 virtual void execute (int numValues, 447 const void* const* inputs, 448 void* const* outputs, 449 VkDescriptorSet extraResources); 450 451 protected: 452 const glu::ShaderType m_shaderType; 453 const FragmentOutputLayout m_outputLayout; 454 455 private: 456 void bindAttributes (int numValues, 457 const void* const* inputs); 458 459 void addAttribute (deUint32 bindingLocation, 460 VkFormat format, 461 deUint32 sizePerElement, 462 deUint32 count, 463 const void* dataPtr); 464 // reinit render data members 465 virtual void clearRenderData (void); 466 467 const VkDescriptorSetLayout m_extraResourcesLayout; 468 469 std::vector<VkVertexInputBindingDescription> m_vertexBindingDescriptions; 470 std::vector<VkVertexInputAttributeDescription> m_vertexAttributeDescriptions; 471 std::vector<VkBufferSp> m_vertexBuffers; 472 std::vector<AllocationSp> m_vertexBufferAllocs; 473 }; 474 475 static FragmentOutputLayout computeFragmentOutputLayout (const std::vector<Symbol>& symbols) 476 { 477 FragmentOutputLayout ret; 478 int location = 0; 479 480 for (std::vector<Symbol>::const_iterator it = symbols.begin(); it != symbols.end(); ++it) 481 { 482 const int numLocations = glu::getDataTypeNumLocations(it->varType.getBasicType()); 483 484 TCU_CHECK_INTERNAL(!de::contains(ret.locationMap, it->name)); 485 de::insert(ret.locationMap, it->name, location); 486 location += numLocations; 487 488 for (int ndx = 0; ndx < numLocations; ++ndx) 489 ret.locationSymbols.push_back(&*it); 490 } 491 492 return ret; 493 } 494 495 FragmentOutExecutor::FragmentOutExecutor (Context& context, glu::ShaderType shaderType, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 496 : ShaderExecutor (context, shaderSpec) 497 , m_shaderType (shaderType) 498 , m_outputLayout (computeFragmentOutputLayout(m_shaderSpec.outputs)) 499 , m_extraResourcesLayout (extraResourcesLayout) 500 { 501 } 502 503 FragmentOutExecutor::~FragmentOutExecutor (void) 504 { 505 } 506 507 static std::vector<tcu::Vec2> computeVertexPositions (int numValues, const tcu::IVec2& renderSize) 508 { 509 std::vector<tcu::Vec2> positions(numValues); 510 for (int valNdx = 0; valNdx < numValues; valNdx++) 511 { 512 const int ix = valNdx % renderSize.x(); 513 const int iy = valNdx / renderSize.x(); 514 const float fx = -1.0f + 2.0f*((float(ix) + 0.5f) / float(renderSize.x())); 515 const float fy = -1.0f + 2.0f*((float(iy) + 0.5f) / float(renderSize.y())); 516 517 positions[valNdx] = tcu::Vec2(fx, fy); 518 } 519 520 return positions; 521 } 522 523 static tcu::TextureFormat getRenderbufferFormatForOutput (const glu::VarType& outputType, bool useIntOutputs) 524 { 525 const tcu::TextureFormat::ChannelOrder channelOrderMap[] = 526 { 527 tcu::TextureFormat::R, 528 tcu::TextureFormat::RG, 529 tcu::TextureFormat::RGBA, // No RGB variants available. 530 tcu::TextureFormat::RGBA 531 }; 532 533 const glu::DataType basicType = outputType.getBasicType(); 534 const int numComps = glu::getDataTypeNumComponents(basicType); 535 tcu::TextureFormat::ChannelType channelType; 536 537 switch (glu::getDataTypeScalarType(basicType)) 538 { 539 case glu::TYPE_UINT: channelType = tcu::TextureFormat::UNSIGNED_INT32; break; 540 case glu::TYPE_INT: channelType = tcu::TextureFormat::SIGNED_INT32; break; 541 case glu::TYPE_BOOL: channelType = tcu::TextureFormat::SIGNED_INT32; break; 542 case glu::TYPE_FLOAT: channelType = useIntOutputs ? tcu::TextureFormat::UNSIGNED_INT32 : tcu::TextureFormat::FLOAT; break; 543 default: 544 throw tcu::InternalError("Invalid output type"); 545 } 546 547 DE_ASSERT(de::inRange<int>(numComps, 1, DE_LENGTH_OF_ARRAY(channelOrderMap))); 548 549 return tcu::TextureFormat(channelOrderMap[numComps-1], channelType); 550 } 551 552 static VkFormat getAttributeFormat (const glu::DataType dataType) 553 { 554 switch (dataType) 555 { 556 case glu::TYPE_FLOAT: return VK_FORMAT_R32_SFLOAT; 557 case glu::TYPE_FLOAT_VEC2: return VK_FORMAT_R32G32_SFLOAT; 558 case glu::TYPE_FLOAT_VEC3: return VK_FORMAT_R32G32B32_SFLOAT; 559 case glu::TYPE_FLOAT_VEC4: return VK_FORMAT_R32G32B32A32_SFLOAT; 560 561 case glu::TYPE_INT: return VK_FORMAT_R32_SINT; 562 case glu::TYPE_INT_VEC2: return VK_FORMAT_R32G32_SINT; 563 case glu::TYPE_INT_VEC3: return VK_FORMAT_R32G32B32_SINT; 564 case glu::TYPE_INT_VEC4: return VK_FORMAT_R32G32B32A32_SINT; 565 566 case glu::TYPE_UINT: return VK_FORMAT_R32_UINT; 567 case glu::TYPE_UINT_VEC2: return VK_FORMAT_R32G32_UINT; 568 case glu::TYPE_UINT_VEC3: return VK_FORMAT_R32G32B32_UINT; 569 case glu::TYPE_UINT_VEC4: return VK_FORMAT_R32G32B32A32_UINT; 570 571 case glu::TYPE_FLOAT_MAT2: return VK_FORMAT_R32G32_SFLOAT; 572 case glu::TYPE_FLOAT_MAT2X3: return VK_FORMAT_R32G32B32_SFLOAT; 573 case glu::TYPE_FLOAT_MAT2X4: return VK_FORMAT_R32G32B32A32_SFLOAT; 574 case glu::TYPE_FLOAT_MAT3X2: return VK_FORMAT_R32G32_SFLOAT; 575 case glu::TYPE_FLOAT_MAT3: return VK_FORMAT_R32G32B32_SFLOAT; 576 case glu::TYPE_FLOAT_MAT3X4: return VK_FORMAT_R32G32B32A32_SFLOAT; 577 case glu::TYPE_FLOAT_MAT4X2: return VK_FORMAT_R32G32_SFLOAT; 578 case glu::TYPE_FLOAT_MAT4X3: return VK_FORMAT_R32G32B32_SFLOAT; 579 case glu::TYPE_FLOAT_MAT4: return VK_FORMAT_R32G32B32A32_SFLOAT; 580 default: 581 DE_ASSERT(false); 582 return VK_FORMAT_UNDEFINED; 583 } 584 } 585 586 void FragmentOutExecutor::addAttribute (deUint32 bindingLocation, VkFormat format, deUint32 sizePerElement, deUint32 count, const void* dataPtr) 587 { 588 // Add binding specification 589 const deUint32 binding = (deUint32)m_vertexBindingDescriptions.size(); 590 const VkVertexInputBindingDescription bindingDescription = 591 { 592 binding, 593 sizePerElement, 594 VK_VERTEX_INPUT_RATE_VERTEX 595 }; 596 597 m_vertexBindingDescriptions.push_back(bindingDescription); 598 599 // Add location and format specification 600 const VkVertexInputAttributeDescription attributeDescription = 601 { 602 bindingLocation, // deUint32 location; 603 binding, // deUint32 binding; 604 format, // VkFormat format; 605 0u, // deUint32 offsetInBytes; 606 }; 607 608 m_vertexAttributeDescriptions.push_back(attributeDescription); 609 610 // Upload data to buffer 611 const VkDevice vkDevice = m_context.getDevice(); 612 const DeviceInterface& vk = m_context.getDeviceInterface(); 613 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 614 615 const VkDeviceSize inputSize = sizePerElement * count; 616 const VkBufferCreateInfo vertexBufferParams = 617 { 618 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; 619 DE_NULL, // const void* pNext; 620 0u, // VkBufferCreateFlags flags; 621 inputSize, // VkDeviceSize size; 622 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage; 623 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 624 1u, // deUint32 queueFamilyCount; 625 &queueFamilyIndex // const deUint32* pQueueFamilyIndices; 626 }; 627 628 Move<VkBuffer> buffer = createBuffer(vk, vkDevice, &vertexBufferParams); 629 de::MovePtr<Allocation> alloc = m_context.getDefaultAllocator().allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible); 630 631 VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, alloc->getMemory(), alloc->getOffset())); 632 633 deMemcpy(alloc->getHostPtr(), dataPtr, (size_t)inputSize); 634 flushMappedMemoryRange(vk, vkDevice, alloc->getMemory(), alloc->getOffset(), inputSize); 635 636 m_vertexBuffers.push_back(de::SharedPtr<Unique<VkBuffer> >(new Unique<VkBuffer>(buffer))); 637 m_vertexBufferAllocs.push_back(AllocationSp(alloc.release())); 638 } 639 640 void FragmentOutExecutor::bindAttributes (int numValues, const void* const* inputs) 641 { 642 // Input attributes 643 for (int inputNdx = 0; inputNdx < (int)m_shaderSpec.inputs.size(); inputNdx++) 644 { 645 const Symbol& symbol = m_shaderSpec.inputs[inputNdx]; 646 const void* ptr = inputs[inputNdx]; 647 const glu::DataType basicType = symbol.varType.getBasicType(); 648 const int vecSize = glu::getDataTypeScalarSize(basicType); 649 const VkFormat format = getAttributeFormat(basicType); 650 int elementSize = 0; 651 int numAttrsToAdd = 1; 652 653 if (glu::isDataTypeFloatOrVec(basicType)) 654 elementSize = sizeof(float); 655 else if (glu::isDataTypeIntOrIVec(basicType)) 656 elementSize = sizeof(int); 657 else if (glu::isDataTypeUintOrUVec(basicType)) 658 elementSize = sizeof(deUint32); 659 else if (glu::isDataTypeMatrix(basicType)) 660 { 661 int numRows = glu::getDataTypeMatrixNumRows(basicType); 662 int numCols = glu::getDataTypeMatrixNumColumns(basicType); 663 664 elementSize = numRows * numCols * (int)sizeof(float); 665 numAttrsToAdd = numCols; 666 } 667 else 668 DE_ASSERT(false); 669 670 // add attributes, in case of matrix every column is binded as an attribute 671 for (int attrNdx = 0; attrNdx < numAttrsToAdd; attrNdx++) 672 { 673 addAttribute((deUint32)m_vertexBindingDescriptions.size(), format, elementSize * vecSize, numValues, ptr); 674 } 675 } 676 } 677 678 void FragmentOutExecutor::clearRenderData (void) 679 { 680 m_vertexBindingDescriptions.clear(); 681 m_vertexAttributeDescriptions.clear(); 682 m_vertexBuffers.clear(); 683 m_vertexBufferAllocs.clear(); 684 } 685 686 static Move<VkDescriptorSetLayout> createEmptyDescriptorSetLayout (const DeviceInterface& vkd, VkDevice device) 687 { 688 const VkDescriptorSetLayoutCreateInfo createInfo = 689 { 690 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, 691 DE_NULL, 692 (VkDescriptorSetLayoutCreateFlags)0, 693 0u, 694 DE_NULL, 695 }; 696 return createDescriptorSetLayout(vkd, device, &createInfo); 697 } 698 699 static Move<VkDescriptorPool> createDummyDescriptorPool (const DeviceInterface& vkd, VkDevice device) 700 { 701 const VkDescriptorPoolSize dummySize = 702 { 703 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 704 1u, 705 }; 706 const VkDescriptorPoolCreateInfo createInfo = 707 { 708 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 709 DE_NULL, 710 (VkDescriptorPoolCreateFlags)VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 711 1u, 712 1u, 713 &dummySize 714 }; 715 return createDescriptorPool(vkd, device, &createInfo); 716 } 717 718 static Move<VkDescriptorSet> allocateSingleDescriptorSet (const DeviceInterface& vkd, VkDevice device, VkDescriptorPool pool, VkDescriptorSetLayout layout) 719 { 720 const VkDescriptorSetAllocateInfo allocInfo = 721 { 722 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 723 DE_NULL, 724 pool, 725 1u, 726 &layout, 727 }; 728 return allocateDescriptorSet(vkd, device, &allocInfo); 729 } 730 731 void FragmentOutExecutor::execute (int numValues, const void* const* inputs, void* const* outputs, VkDescriptorSet extraResources) 732 { 733 const VkDevice vkDevice = m_context.getDevice(); 734 const DeviceInterface& vk = m_context.getDeviceInterface(); 735 const VkQueue queue = m_context.getUniversalQueue(); 736 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 737 Allocator& memAlloc = m_context.getDefaultAllocator(); 738 739 const deUint32 renderSizeX = de::min(static_cast<deUint32>(DEFAULT_RENDER_WIDTH), (deUint32)numValues); 740 const deUint32 renderSizeY = ((deUint32)numValues / renderSizeX) + (((deUint32)numValues % renderSizeX != 0) ? 1u : 0u); 741 const tcu::UVec2 renderSize (renderSizeX, renderSizeY); 742 std::vector<tcu::Vec2> positions; 743 744 const bool useGeometryShader = m_shaderType == glu::SHADERTYPE_GEOMETRY; 745 746 std::vector<VkImageSp> colorImages; 747 std::vector<VkImageMemoryBarrier> colorImagePreRenderBarriers; 748 std::vector<VkImageMemoryBarrier> colorImagePostRenderBarriers; 749 std::vector<AllocationSp> colorImageAllocs; 750 std::vector<VkAttachmentDescription> attachments; 751 std::vector<VkClearValue> attachmentClearValues; 752 std::vector<VkImageViewSp> colorImageViews; 753 754 std::vector<VkPipelineColorBlendAttachmentState> colorBlendAttachmentStates; 755 std::vector<VkAttachmentReference> colorAttachmentReferences; 756 757 Move<VkRenderPass> renderPass; 758 Move<VkFramebuffer> framebuffer; 759 Move<VkPipelineLayout> pipelineLayout; 760 Move<VkPipeline> graphicsPipeline; 761 762 Move<VkShaderModule> vertexShaderModule; 763 Move<VkShaderModule> geometryShaderModule; 764 Move<VkShaderModule> fragmentShaderModule; 765 766 Move<VkCommandPool> cmdPool; 767 Move<VkCommandBuffer> cmdBuffer; 768 769 Move<VkFence> fence; 770 771 Unique<VkDescriptorSetLayout> emptyDescriptorSetLayout (createEmptyDescriptorSetLayout(vk, vkDevice)); 772 Unique<VkDescriptorPool> dummyDescriptorPool (createDummyDescriptorPool(vk, vkDevice)); 773 Unique<VkDescriptorSet> emptyDescriptorSet (allocateSingleDescriptorSet(vk, vkDevice, *dummyDescriptorPool, *emptyDescriptorSetLayout)); 774 775 clearRenderData(); 776 777 // Compute positions - 1px points are used to drive fragment shading. 778 positions = computeVertexPositions(numValues, renderSize.cast<int>()); 779 780 // Bind attributes 781 addAttribute(0u, VK_FORMAT_R32G32_SFLOAT, sizeof(tcu::Vec2), (deUint32)positions.size(), &positions[0]); 782 bindAttributes(numValues, inputs); 783 784 // Create color images 785 { 786 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = 787 { 788 VK_FALSE, // VkBool32 blendEnable; 789 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor; 790 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor; 791 VK_BLEND_OP_ADD, // VkBlendOp blendOpColor; 792 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor; 793 VK_BLEND_FACTOR_ZERO, // VkBlendFactor destAlphaBlendFactor; 794 VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha; 795 (VK_COLOR_COMPONENT_R_BIT | 796 VK_COLOR_COMPONENT_G_BIT | 797 VK_COLOR_COMPONENT_B_BIT | 798 VK_COLOR_COMPONENT_A_BIT) // VkColorComponentFlags colorWriteMask; 799 }; 800 801 for (int outNdx = 0; outNdx < (int)m_outputLayout.locationSymbols.size(); ++outNdx) 802 { 803 const bool isFloat = isDataTypeFloatOrVec(m_shaderSpec.outputs[outNdx].varType.getBasicType()); 804 const bool isSigned = isDataTypeIntOrIVec (m_shaderSpec.outputs[outNdx].varType.getBasicType()); 805 const bool isBool = isDataTypeBoolOrBVec(m_shaderSpec.outputs[outNdx].varType.getBasicType()); 806 const VkFormat colorFormat = isFloat ? VK_FORMAT_R32G32B32A32_SFLOAT : (isSigned || isBool ? VK_FORMAT_R32G32B32A32_SINT : VK_FORMAT_R32G32B32A32_UINT); 807 808 const VkImageCreateInfo colorImageParams = 809 { 810 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; 811 DE_NULL, // const void* pNext; 812 0u, // VkImageCreateFlags flags; 813 VK_IMAGE_TYPE_2D, // VkImageType imageType; 814 colorFormat, // VkFormat format; 815 { renderSize.x(), renderSize.y(), 1u }, // VkExtent3D extent; 816 1u, // deUint32 mipLevels; 817 1u, // deUint32 arraySize; 818 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 819 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; 820 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage; 821 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 822 1u, // deUint32 queueFamilyCount; 823 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices; 824 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; 825 }; 826 827 const VkAttachmentDescription colorAttachmentDescription = 828 { 829 0u, // VkAttachmentDescriptorFlags flags; 830 colorFormat, // VkFormat format; 831 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 832 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; 833 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; 834 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; 835 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; 836 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout; 837 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout; 838 }; 839 840 Move<VkImage> colorImage = createImage(vk, vkDevice, &colorImageParams); 841 colorImages.push_back(de::SharedPtr<Unique<VkImage> >(new Unique<VkImage>(colorImage))); 842 attachmentClearValues.push_back(getDefaultClearColor()); 843 844 // Allocate and bind color image memory 845 { 846 de::MovePtr<Allocation> colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *((const VkImage*) colorImages.back().get())), MemoryRequirement::Any); 847 VK_CHECK(vk.bindImageMemory(vkDevice, colorImages.back().get()->get(), colorImageAlloc->getMemory(), colorImageAlloc->getOffset())); 848 colorImageAllocs.push_back(de::SharedPtr<Allocation>(colorImageAlloc.release())); 849 850 attachments.push_back(colorAttachmentDescription); 851 colorBlendAttachmentStates.push_back(colorBlendAttachmentState); 852 853 const VkAttachmentReference colorAttachmentReference = 854 { 855 (deUint32) (colorImages.size() - 1), // deUint32 attachment; 856 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; 857 }; 858 859 colorAttachmentReferences.push_back(colorAttachmentReference); 860 } 861 862 // Create color attachment view 863 { 864 const VkImageViewCreateInfo colorImageViewParams = 865 { 866 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; 867 DE_NULL, // const void* pNext; 868 0u, // VkImageViewCreateFlags flags; 869 colorImages.back().get()->get(), // VkImage image; 870 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType; 871 colorFormat, // VkFormat format; 872 { 873 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r; 874 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g; 875 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b; 876 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a; 877 }, // VkComponentMapping components; 878 { 879 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask; 880 0u, // deUint32 baseMipLevel; 881 1u, // deUint32 mipLevels; 882 0u, // deUint32 baseArraySlice; 883 1u // deUint32 arraySize; 884 } // VkImageSubresourceRange subresourceRange; 885 }; 886 887 Move<VkImageView> colorImageView = createImageView(vk, vkDevice, &colorImageViewParams); 888 colorImageViews.push_back(de::SharedPtr<Unique<VkImageView> >(new Unique<VkImageView>(colorImageView))); 889 890 const VkImageMemoryBarrier colorImagePreRenderBarrier = 891 { 892 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType 893 DE_NULL, // pNext 894 0u, // srcAccessMask 895 (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | 896 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT), // dstAccessMask 897 VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout 898 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout 899 VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex 900 VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex 901 colorImages.back().get()->get(), // image 902 { 903 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask 904 0u, // baseMipLevel 905 1u, // levelCount 906 0u, // baseArrayLayer 907 1u, // layerCount 908 } // subresourceRange 909 }; 910 colorImagePreRenderBarriers.push_back(colorImagePreRenderBarrier); 911 912 const VkImageMemoryBarrier colorImagePostRenderBarrier = 913 { 914 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType 915 DE_NULL, // pNext 916 (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | 917 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT), // srcAccessMask 918 VK_ACCESS_TRANSFER_READ_BIT, // dstAccessMask 919 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // oldLayout 920 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // newLayout 921 VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex 922 VK_QUEUE_FAMILY_IGNORED, // dstQueueFamilyIndex 923 colorImages.back().get()->get(), // image 924 { 925 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask 926 0u, // baseMipLevel 927 1u, // levelCount 928 0u, // baseArrayLayer 929 1u, // layerCount 930 } // subresourceRange 931 }; 932 colorImagePostRenderBarriers.push_back(colorImagePostRenderBarrier); 933 } 934 } 935 } 936 937 // Create render pass 938 { 939 const VkSubpassDescription subpassDescription = 940 { 941 0u, // VkSubpassDescriptionFlags flags; 942 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; 943 0u, // deUint32 inputCount; 944 DE_NULL, // const VkAttachmentReference* pInputAttachments; 945 (deUint32)colorImages.size(), // deUint32 colorCount; 946 &colorAttachmentReferences[0], // const VkAttachmentReference* colorAttachments; 947 DE_NULL, // const VkAttachmentReference* resolveAttachments; 948 DE_NULL, // VkAttachmentReference depthStencilAttachment; 949 0u, // deUint32 preserveCount; 950 DE_NULL // const VkAttachmentReference* pPreserveAttachments; 951 }; 952 953 const VkRenderPassCreateInfo renderPassParams = 954 { 955 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; 956 DE_NULL, // const void* pNext; 957 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags; 958 (deUint32)attachments.size(), // deUint32 attachmentCount; 959 &attachments[0], // const VkAttachmentDescription* pAttachments; 960 1u, // deUint32 subpassCount; 961 &subpassDescription, // const VkSubpassDescription* pSubpasses; 962 0u, // deUint32 dependencyCount; 963 DE_NULL // const VkSubpassDependency* pDependencies; 964 }; 965 966 renderPass = createRenderPass(vk, vkDevice, &renderPassParams); 967 } 968 969 // Create framebuffer 970 { 971 std::vector<VkImageView> views(colorImageViews.size()); 972 for (size_t i = 0; i < colorImageViews.size(); i++) 973 { 974 views[i] = colorImageViews[i].get()->get(); 975 } 976 977 const VkFramebufferCreateInfo framebufferParams = 978 { 979 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; 980 DE_NULL, // const void* pNext; 981 0u, // VkFramebufferCreateFlags flags; 982 *renderPass, // VkRenderPass renderPass; 983 (deUint32)views.size(), // deUint32 attachmentCount; 984 &views[0], // const VkImageView* pAttachments; 985 (deUint32)renderSize.x(), // deUint32 width; 986 (deUint32)renderSize.y(), // deUint32 height; 987 1u // deUint32 layers; 988 }; 989 990 framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams); 991 } 992 993 // Create pipeline layout 994 { 995 const VkDescriptorSetLayout setLayouts[] = 996 { 997 *emptyDescriptorSetLayout, 998 m_extraResourcesLayout 999 }; 1000 const VkPipelineLayoutCreateInfo pipelineLayoutParams = 1001 { 1002 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 1003 DE_NULL, // const void* pNext; 1004 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags; 1005 (m_extraResourcesLayout != 0 ? 2u : 0u), // deUint32 descriptorSetCount; 1006 setLayouts, // const VkDescriptorSetLayout* pSetLayouts; 1007 0u, // deUint32 pushConstantRangeCount; 1008 DE_NULL // const VkPushConstantRange* pPushConstantRanges; 1009 }; 1010 1011 pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams); 1012 } 1013 1014 // Create shaders 1015 { 1016 vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("vert"), 0); 1017 fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("frag"), 0); 1018 1019 if (useGeometryShader) 1020 { 1021 geometryShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("geom"), 0); 1022 } 1023 } 1024 1025 // Create pipeline 1026 { 1027 std::vector<VkPipelineShaderStageCreateInfo> shaderStageParams; 1028 1029 const VkPipelineShaderStageCreateInfo vertexShaderStageParams = 1030 { 1031 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 1032 DE_NULL, // const void* pNext; 1033 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 1034 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage; 1035 *vertexShaderModule, // VkShaderModule module; 1036 "main", // const char* pName; 1037 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 1038 }; 1039 1040 const VkPipelineShaderStageCreateInfo fragmentShaderStageParams = 1041 { 1042 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 1043 DE_NULL, // const void* pNext; 1044 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 1045 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage; 1046 *fragmentShaderModule, // VkShaderModule module; 1047 "main", // const char* pName; 1048 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 1049 }; 1050 1051 shaderStageParams.push_back(vertexShaderStageParams); 1052 shaderStageParams.push_back(fragmentShaderStageParams); 1053 1054 if (useGeometryShader) 1055 { 1056 const VkPipelineShaderStageCreateInfo geometryShaderStageParams = 1057 { 1058 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 1059 DE_NULL, // const void* pNext; 1060 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 1061 VK_SHADER_STAGE_GEOMETRY_BIT, // VkShaderStageFlagBits stage; 1062 *geometryShaderModule, // VkShaderModule module; 1063 "main", // VkShader shader; 1064 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 1065 }; 1066 1067 shaderStageParams.push_back(geometryShaderStageParams); 1068 } 1069 1070 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams = 1071 { 1072 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; 1073 DE_NULL, // const void* pNext; 1074 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags; 1075 (deUint32)m_vertexBindingDescriptions.size(), // deUint32 bindingCount; 1076 &m_vertexBindingDescriptions[0], // const VkVertexInputBindingDescription* pVertexBindingDescriptions; 1077 (deUint32)m_vertexAttributeDescriptions.size(), // deUint32 attributeCount; 1078 &m_vertexAttributeDescriptions[0], // const VkVertexInputAttributeDescription* pvertexAttributeDescriptions; 1079 }; 1080 1081 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams = 1082 { 1083 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; 1084 DE_NULL, // const void* pNext; 1085 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags; 1086 VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // VkPrimitiveTopology topology; 1087 DE_FALSE // VkBool32 primitiveRestartEnable; 1088 }; 1089 1090 const VkViewport viewport = 1091 { 1092 0.0f, // float originX; 1093 0.0f, // float originY; 1094 (float)renderSize.x(), // float width; 1095 (float)renderSize.y(), // float height; 1096 0.0f, // float minDepth; 1097 1.0f // float maxDepth; 1098 }; 1099 1100 const VkRect2D scissor = 1101 { 1102 { 1103 0u, // deUint32 x; 1104 0u, // deUint32 y; 1105 }, // VkOffset2D offset; 1106 { 1107 renderSize.x(), // deUint32 width; 1108 renderSize.y(), // deUint32 height; 1109 }, // VkExtent2D extent; 1110 }; 1111 1112 const VkPipelineViewportStateCreateInfo viewportStateParams = 1113 { 1114 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; 1115 DE_NULL, // const void* pNext; 1116 0u, // VkPipelineViewportStateCreateFlags flags; 1117 1u, // deUint32 viewportCount; 1118 &viewport, // const VkViewport* pViewports; 1119 1u, // deUint32 scissorsCount; 1120 &scissor // const VkRect2D* pScissors; 1121 }; 1122 1123 const VkPipelineRasterizationStateCreateInfo rasterStateParams = 1124 { 1125 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType; 1126 DE_NULL, // const void* pNext; 1127 (VkPipelineRasterizationStateCreateFlags)0u, //VkPipelineRasterizationStateCreateFlags flags; 1128 VK_FALSE, // VkBool32 depthClipEnable; 1129 VK_FALSE, // VkBool32 rasterizerDiscardEnable; 1130 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode; 1131 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode; 1132 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace; 1133 VK_FALSE, // VkBool32 depthBiasEnable; 1134 0.0f, // float depthBias; 1135 0.0f, // float depthBiasClamp; 1136 0.0f, // float slopeScaledDepthBias; 1137 1.0f // float lineWidth; 1138 }; 1139 1140 const VkPipelineMultisampleStateCreateInfo multisampleStateParams = 1141 { 1142 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; 1143 DE_NULL, // const void* pNext; 1144 0u, // VkPipelineMultisampleStateCreateFlags flags; 1145 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples; 1146 VK_FALSE, // VkBool32 sampleShadingEnable; 1147 0.0f, // float minSampleShading; 1148 DE_NULL, // const VkSampleMask* pSampleMask; 1149 VK_FALSE, // VkBool32 alphaToCoverageEnable; 1150 VK_FALSE // VkBool32 alphaToOneEnable; 1151 }; 1152 1153 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams = 1154 { 1155 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; 1156 DE_NULL, // const void* pNext; 1157 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags; 1158 VK_FALSE, // VkBool32 logicOpEnable; 1159 VK_LOGIC_OP_COPY, // VkLogicOp logicOp; 1160 (deUint32)colorBlendAttachmentStates.size(), // deUint32 attachmentCount; 1161 &colorBlendAttachmentStates[0], // const VkPipelineColorBlendAttachmentState* pAttachments; 1162 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConst[4]; 1163 }; 1164 1165 const VkGraphicsPipelineCreateInfo graphicsPipelineParams = 1166 { 1167 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; 1168 DE_NULL, // const void* pNext; 1169 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags; 1170 (deUint32)shaderStageParams.size(), // deUint32 stageCount; 1171 &shaderStageParams[0], // const VkPipelineShaderStageCreateInfo* pStages; 1172 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 1173 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 1174 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState; 1175 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState; 1176 &rasterStateParams, // const VkPipelineRasterStateCreateInfo* pRasterState; 1177 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 1178 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 1179 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 1180 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState; 1181 *pipelineLayout, // VkPipelineLayout layout; 1182 *renderPass, // VkRenderPass renderPass; 1183 0u, // deUint32 subpass; 1184 0u, // VkPipeline basePipelineHandle; 1185 0u // deInt32 basePipelineIndex; 1186 }; 1187 1188 graphicsPipeline = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams); 1189 } 1190 1191 // Create command pool 1192 cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex); 1193 1194 // Create command buffer 1195 { 1196 const VkCommandBufferBeginInfo cmdBufferBeginInfo = 1197 { 1198 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; 1199 DE_NULL, // const void* pNext; 1200 0u, // VkCmdBufferOptimizeFlags flags; 1201 (const VkCommandBufferInheritanceInfo*)DE_NULL, 1202 }; 1203 1204 const VkRenderPassBeginInfo renderPassBeginInfo = 1205 { 1206 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType; 1207 DE_NULL, // const void* pNext; 1208 *renderPass, // VkRenderPass renderPass; 1209 *framebuffer, // VkFramebuffer framebuffer; 1210 { { 0, 0 }, { renderSize.x(), renderSize.y() } }, // VkRect2D renderArea; 1211 (deUint32)attachmentClearValues.size(), // deUint32 attachmentCount; 1212 &attachmentClearValues[0] // const VkClearValue* pAttachmentClearValues; 1213 }; 1214 1215 cmdBuffer = allocateCommandBuffer(vk, vkDevice, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); 1216 1217 VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo)); 1218 1219 vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 1220 0, (const VkMemoryBarrier*)DE_NULL, 1221 0, (const VkBufferMemoryBarrier*)DE_NULL, 1222 (deUint32)colorImagePreRenderBarriers.size(), colorImagePreRenderBarriers.empty() ? DE_NULL : &colorImagePreRenderBarriers[0]); 1223 vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); 1224 1225 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline); 1226 1227 if (m_extraResourcesLayout != 0) 1228 { 1229 DE_ASSERT(extraResources != 0); 1230 const VkDescriptorSet descriptorSets[] = { *emptyDescriptorSet, extraResources }; 1231 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, DE_LENGTH_OF_ARRAY(descriptorSets), descriptorSets, 0u, DE_NULL); 1232 } 1233 else 1234 DE_ASSERT(extraResources == 0); 1235 1236 const deUint32 numberOfVertexAttributes = (deUint32)m_vertexBuffers.size(); 1237 1238 std::vector<VkDeviceSize> offsets(numberOfVertexAttributes, 0); 1239 1240 std::vector<VkBuffer> buffers(numberOfVertexAttributes); 1241 for (size_t i = 0; i < numberOfVertexAttributes; i++) 1242 { 1243 buffers[i] = m_vertexBuffers[i].get()->get(); 1244 } 1245 1246 vk.cmdBindVertexBuffers(*cmdBuffer, 0, numberOfVertexAttributes, &buffers[0], &offsets[0]); 1247 vk.cmdDraw(*cmdBuffer, (deUint32)positions.size(), 1u, 0u, 0u); 1248 1249 vk.cmdEndRenderPass(*cmdBuffer); 1250 vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 1251 0, (const VkMemoryBarrier*)DE_NULL, 1252 0, (const VkBufferMemoryBarrier*)DE_NULL, 1253 (deUint32)colorImagePostRenderBarriers.size(), colorImagePostRenderBarriers.empty() ? DE_NULL : &colorImagePostRenderBarriers[0]); 1254 1255 VK_CHECK(vk.endCommandBuffer(*cmdBuffer)); 1256 } 1257 1258 // Create fence 1259 fence = createFence(vk, vkDevice); 1260 1261 // Execute Draw 1262 { 1263 1264 const VkSubmitInfo submitInfo = 1265 { 1266 VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType 1267 DE_NULL, // pNext 1268 0u, // waitSemaphoreCount 1269 DE_NULL, // pWaitSemaphores 1270 (const VkPipelineStageFlags*)DE_NULL, 1271 1u, // commandBufferCount 1272 &cmdBuffer.get(), // pCommandBuffers 1273 0u, // signalSemaphoreCount 1274 DE_NULL // pSignalSemaphores 1275 }; 1276 1277 VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get())); 1278 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence)); 1279 VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), DE_TRUE, ~(0ull) /* infinity*/)); 1280 } 1281 1282 // Read back result and output 1283 { 1284 const VkDeviceSize imageSizeBytes = (VkDeviceSize)(4 * sizeof(deUint32) * renderSize.x() * renderSize.y()); 1285 const VkBufferCreateInfo readImageBufferParams = 1286 { 1287 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; 1288 DE_NULL, // const void* pNext; 1289 0u, // VkBufferCreateFlags flags; 1290 imageSizeBytes, // VkDeviceSize size; 1291 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage; 1292 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 1293 1u, // deUint32 queueFamilyCount; 1294 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices; 1295 }; 1296 1297 // constants for image copy 1298 Move<VkCommandPool> copyCmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex); 1299 1300 const VkCommandBufferBeginInfo cmdBufferBeginInfo = 1301 { 1302 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; 1303 DE_NULL, // const void* pNext; 1304 0u, // VkCmdBufferOptimizeFlags flags; 1305 (const VkCommandBufferInheritanceInfo*)DE_NULL, 1306 }; 1307 1308 const VkBufferImageCopy copyParams = 1309 { 1310 0u, // VkDeviceSize bufferOffset; 1311 (deUint32)renderSize.x(), // deUint32 bufferRowLength; 1312 (deUint32)renderSize.y(), // deUint32 bufferImageHeight; 1313 { 1314 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspect aspect; 1315 0u, // deUint32 mipLevel; 1316 0u, // deUint32 arraySlice; 1317 1u, // deUint32 arraySize; 1318 }, // VkImageSubresource imageSubresource; 1319 { 0u, 0u, 0u }, // VkOffset3D imageOffset; 1320 { renderSize.x(), renderSize.y(), 1u } // VkExtent3D imageExtent; 1321 }; 1322 1323 // Read back pixels. 1324 for (int outNdx = 0; outNdx < (int)m_shaderSpec.outputs.size(); ++outNdx) 1325 { 1326 const Symbol& output = m_shaderSpec.outputs[outNdx]; 1327 const int outSize = output.varType.getScalarSize(); 1328 const int outVecSize = glu::getDataTypeNumComponents(output.varType.getBasicType()); 1329 const int outNumLocs = glu::getDataTypeNumLocations(output.varType.getBasicType()); 1330 deUint32* dstPtrBase = static_cast<deUint32*>(outputs[outNdx]); 1331 const int outLocation = de::lookup(m_outputLayout.locationMap, output.name); 1332 1333 for (int locNdx = 0; locNdx < outNumLocs; ++locNdx) 1334 { 1335 tcu::TextureLevel tmpBuf; 1336 const tcu::TextureFormat format = getRenderbufferFormatForOutput(output.varType, false); 1337 const tcu::TextureFormat readFormat (tcu::TextureFormat::RGBA, format.type); 1338 const Unique<VkBuffer> readImageBuffer(createBuffer(vk, vkDevice, &readImageBufferParams)); 1339 const de::UniquePtr<Allocation> readImageBufferMemory(memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible)); 1340 1341 VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset())); 1342 1343 // Copy image to buffer 1344 { 1345 1346 Move<VkCommandBuffer> copyCmdBuffer = allocateCommandBuffer(vk, vkDevice, *copyCmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); 1347 1348 const VkSubmitInfo submitInfo = 1349 { 1350 VK_STRUCTURE_TYPE_SUBMIT_INFO, 1351 DE_NULL, 1352 0u, 1353 (const VkSemaphore*)DE_NULL, 1354 (const VkPipelineStageFlags*)DE_NULL, 1355 1u, 1356 ©CmdBuffer.get(), 1357 0u, 1358 (const VkSemaphore*)DE_NULL, 1359 }; 1360 1361 VK_CHECK(vk.beginCommandBuffer(*copyCmdBuffer, &cmdBufferBeginInfo)); 1362 vk.cmdCopyImageToBuffer(*copyCmdBuffer, colorImages[outLocation + locNdx].get()->get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *readImageBuffer, 1u, ©Params); 1363 VK_CHECK(vk.endCommandBuffer(*copyCmdBuffer)); 1364 1365 VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get())); 1366 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence)); 1367 VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */)); 1368 } 1369 1370 const VkMappedMemoryRange range = 1371 { 1372 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, // VkStructureType sType; 1373 DE_NULL, // const void* pNext; 1374 readImageBufferMemory->getMemory(), // VkDeviceMemory mem; 1375 0, // VkDeviceSize offset; 1376 imageSizeBytes, // VkDeviceSize size; 1377 }; 1378 1379 VK_CHECK(vk.invalidateMappedMemoryRanges(vkDevice, 1u, &range)); 1380 1381 tmpBuf.setStorage(readFormat, renderSize.x(), renderSize.y()); 1382 1383 const tcu::TextureFormat resultFormat(tcu::TextureFormat::RGBA, format.type); 1384 const tcu::ConstPixelBufferAccess resultAccess(resultFormat, renderSize.x(), renderSize.y(), 1, readImageBufferMemory->getHostPtr()); 1385 1386 tcu::copy(tmpBuf.getAccess(), resultAccess); 1387 1388 if (outSize == 4 && outNumLocs == 1) 1389 deMemcpy(dstPtrBase, tmpBuf.getAccess().getDataPtr(), numValues * outVecSize * sizeof(deUint32)); 1390 else 1391 { 1392 for (int valNdx = 0; valNdx < numValues; valNdx++) 1393 { 1394 const deUint32* srcPtr = (const deUint32*)tmpBuf.getAccess().getDataPtr() + valNdx * 4; 1395 deUint32* dstPtr = &dstPtrBase[outSize * valNdx + outVecSize * locNdx]; 1396 deMemcpy(dstPtr, srcPtr, outVecSize * sizeof(deUint32)); 1397 } 1398 } 1399 } 1400 } 1401 } 1402 } 1403 1404 // VertexShaderExecutor 1405 1406 class VertexShaderExecutor : public FragmentOutExecutor 1407 { 1408 public: 1409 VertexShaderExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout); 1410 virtual ~VertexShaderExecutor (void); 1411 1412 static void generateSources (const ShaderSpec& shaderSpec, SourceCollections& dst); 1413 }; 1414 1415 VertexShaderExecutor::VertexShaderExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 1416 : FragmentOutExecutor(context, glu::SHADERTYPE_VERTEX, shaderSpec, extraResourcesLayout) 1417 { 1418 } 1419 1420 VertexShaderExecutor::~VertexShaderExecutor (void) 1421 { 1422 } 1423 1424 void VertexShaderExecutor::generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection) 1425 { 1426 const FragmentOutputLayout outputLayout (computeFragmentOutputLayout(shaderSpec.outputs)); 1427 1428 programCollection.glslSources.add("vert") << glu::VertexSource(generateVertexShader(shaderSpec, "a_", "vtx_out_")) << shaderSpec.buildOptions; 1429 /* \todo [2015-09-11 hegedusd] set useIntOutputs parameter if needed. */ 1430 programCollection.glslSources.add("frag") << glu::FragmentSource(generatePassthroughFragmentShader(shaderSpec, false, outputLayout.locationMap, "vtx_out_", "o_")) << shaderSpec.buildOptions; 1431 } 1432 1433 // GeometryShaderExecutor 1434 1435 class GeometryShaderExecutor : public FragmentOutExecutor 1436 { 1437 public: 1438 GeometryShaderExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout); 1439 virtual ~GeometryShaderExecutor (void); 1440 1441 static void generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection); 1442 1443 }; 1444 1445 GeometryShaderExecutor::GeometryShaderExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 1446 : FragmentOutExecutor(context, glu::SHADERTYPE_GEOMETRY, shaderSpec, extraResourcesLayout) 1447 { 1448 const VkPhysicalDeviceFeatures& features = context.getDeviceFeatures(); 1449 1450 if (!features.geometryShader) 1451 TCU_THROW(NotSupportedError, "Geometry shader type not supported by device"); 1452 } 1453 1454 GeometryShaderExecutor::~GeometryShaderExecutor (void) 1455 { 1456 } 1457 1458 void GeometryShaderExecutor::generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection) 1459 { 1460 const FragmentOutputLayout outputLayout (computeFragmentOutputLayout(shaderSpec.outputs)); 1461 1462 programCollection.glslSources.add("vert") << glu::VertexSource(generatePassthroughVertexShader(shaderSpec.inputs, "a_", "vtx_out_")) << shaderSpec.buildOptions; 1463 1464 programCollection.glslSources.add("geom") << glu::GeometrySource(generateGeometryShader(shaderSpec, "vtx_out_", "geom_out_")) << shaderSpec.buildOptions; 1465 1466 /* \todo [2015-09-18 rsipka] set useIntOutputs parameter if needed. */ 1467 programCollection.glslSources.add("frag") << glu::FragmentSource(generatePassthroughFragmentShader(shaderSpec, false, outputLayout.locationMap, "geom_out_", "o_")) << shaderSpec.buildOptions; 1468 1469 } 1470 1471 // FragmentShaderExecutor 1472 1473 class FragmentShaderExecutor : public FragmentOutExecutor 1474 { 1475 public: 1476 FragmentShaderExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout); 1477 virtual ~FragmentShaderExecutor (void); 1478 1479 static void generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection); 1480 1481 }; 1482 1483 FragmentShaderExecutor::FragmentShaderExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 1484 : FragmentOutExecutor(context, glu::SHADERTYPE_FRAGMENT, shaderSpec, extraResourcesLayout) 1485 { 1486 } 1487 1488 FragmentShaderExecutor::~FragmentShaderExecutor (void) 1489 { 1490 } 1491 1492 void FragmentShaderExecutor::generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection) 1493 { 1494 const FragmentOutputLayout outputLayout (computeFragmentOutputLayout(shaderSpec.outputs)); 1495 1496 programCollection.glslSources.add("vert") << glu::VertexSource(generatePassthroughVertexShader(shaderSpec.inputs, "a_", "vtx_out_")) << shaderSpec.buildOptions; 1497 /* \todo [2015-09-11 hegedusd] set useIntOutputs parameter if needed. */ 1498 programCollection.glslSources.add("frag") << glu::FragmentSource(generateFragmentShader(shaderSpec, false, outputLayout.locationMap, "vtx_out_", "o_")) << shaderSpec.buildOptions; 1499 } 1500 1501 // Shared utilities for compute and tess executors 1502 1503 static deUint32 getVecStd430ByteAlignment (glu::DataType type) 1504 { 1505 switch (glu::getDataTypeScalarSize(type)) 1506 { 1507 case 1: return 4u; 1508 case 2: return 8u; 1509 case 3: return 16u; 1510 case 4: return 16u; 1511 default: 1512 DE_ASSERT(false); 1513 return 0u; 1514 } 1515 } 1516 1517 class BufferIoExecutor : public ShaderExecutor 1518 { 1519 public: 1520 BufferIoExecutor (Context& context, const ShaderSpec& shaderSpec); 1521 virtual ~BufferIoExecutor (void); 1522 1523 protected: 1524 enum 1525 { 1526 INPUT_BUFFER_BINDING = 0, 1527 OUTPUT_BUFFER_BINDING = 1, 1528 }; 1529 1530 void initBuffers (int numValues); 1531 VkBuffer getInputBuffer (void) const { return *m_inputBuffer; } 1532 VkBuffer getOutputBuffer (void) const { return *m_outputBuffer; } 1533 deUint32 getInputStride (void) const { return getLayoutStride(m_inputLayout); } 1534 deUint32 getOutputStride (void) const { return getLayoutStride(m_outputLayout); } 1535 1536 void uploadInputBuffer (const void* const* inputPtrs, int numValues); 1537 void readOutputBuffer (void* const* outputPtrs, int numValues); 1538 1539 static void declareBufferBlocks (std::ostream& src, const ShaderSpec& spec); 1540 static void generateExecBufferIo(std::ostream& src, const ShaderSpec& spec, const char* invocationNdxName); 1541 1542 protected: 1543 Move<VkBuffer> m_inputBuffer; 1544 Move<VkBuffer> m_outputBuffer; 1545 1546 private: 1547 struct VarLayout 1548 { 1549 deUint32 offset; 1550 deUint32 stride; 1551 deUint32 matrixStride; 1552 1553 VarLayout (void) : offset(0), stride(0), matrixStride(0) {} 1554 }; 1555 1556 static void computeVarLayout (const std::vector<Symbol>& symbols, std::vector<VarLayout>* layout); 1557 static deUint32 getLayoutStride (const vector<VarLayout>& layout); 1558 1559 static void copyToBuffer (const glu::VarType& varType, const VarLayout& layout, int numValues, const void* srcBasePtr, void* dstBasePtr); 1560 static void copyFromBuffer (const glu::VarType& varType, const VarLayout& layout, int numValues, const void* srcBasePtr, void* dstBasePtr); 1561 1562 de::MovePtr<Allocation> m_inputAlloc; 1563 de::MovePtr<Allocation> m_outputAlloc; 1564 1565 vector<VarLayout> m_inputLayout; 1566 vector<VarLayout> m_outputLayout; 1567 }; 1568 1569 BufferIoExecutor::BufferIoExecutor (Context& context, const ShaderSpec& shaderSpec) 1570 : ShaderExecutor(context, shaderSpec) 1571 { 1572 computeVarLayout(m_shaderSpec.inputs, &m_inputLayout); 1573 computeVarLayout(m_shaderSpec.outputs, &m_outputLayout); 1574 } 1575 1576 BufferIoExecutor::~BufferIoExecutor (void) 1577 { 1578 } 1579 1580 inline deUint32 BufferIoExecutor::getLayoutStride (const vector<VarLayout>& layout) 1581 { 1582 return layout.empty() ? 0 : layout[0].stride; 1583 } 1584 1585 void BufferIoExecutor::computeVarLayout (const std::vector<Symbol>& symbols, std::vector<VarLayout>* layout) 1586 { 1587 deUint32 maxAlignment = 0; 1588 deUint32 curOffset = 0; 1589 1590 DE_ASSERT(layout != DE_NULL); 1591 DE_ASSERT(layout->empty()); 1592 layout->resize(symbols.size()); 1593 1594 for (size_t varNdx = 0; varNdx < symbols.size(); varNdx++) 1595 { 1596 const Symbol& symbol = symbols[varNdx]; 1597 const glu::DataType basicType = symbol.varType.getBasicType(); 1598 VarLayout& layoutEntry = (*layout)[varNdx]; 1599 1600 if (glu::isDataTypeScalarOrVector(basicType)) 1601 { 1602 const deUint32 alignment = getVecStd430ByteAlignment(basicType); 1603 const deUint32 size = (deUint32)glu::getDataTypeScalarSize(basicType) * (int)sizeof(deUint32); 1604 1605 curOffset = (deUint32)deAlign32((int)curOffset, (int)alignment); 1606 maxAlignment = de::max(maxAlignment, alignment); 1607 1608 layoutEntry.offset = curOffset; 1609 layoutEntry.matrixStride = 0; 1610 1611 curOffset += size; 1612 } 1613 else if (glu::isDataTypeMatrix(basicType)) 1614 { 1615 const int numVecs = glu::getDataTypeMatrixNumColumns(basicType); 1616 const glu::DataType vecType = glu::getDataTypeFloatVec(glu::getDataTypeMatrixNumRows(basicType)); 1617 const deUint32 vecAlignment = getVecStd430ByteAlignment(vecType); 1618 1619 curOffset = (deUint32)deAlign32((int)curOffset, (int)vecAlignment); 1620 maxAlignment = de::max(maxAlignment, vecAlignment); 1621 1622 layoutEntry.offset = curOffset; 1623 layoutEntry.matrixStride = vecAlignment; 1624 1625 curOffset += vecAlignment*numVecs; 1626 } 1627 else 1628 DE_ASSERT(false); 1629 } 1630 1631 { 1632 const deUint32 totalSize = (deUint32)deAlign32(curOffset, maxAlignment); 1633 1634 for (vector<VarLayout>::iterator varIter = layout->begin(); varIter != layout->end(); ++varIter) 1635 varIter->stride = totalSize; 1636 } 1637 } 1638 1639 void BufferIoExecutor::declareBufferBlocks (std::ostream& src, const ShaderSpec& spec) 1640 { 1641 // Input struct 1642 if (!spec.inputs.empty()) 1643 { 1644 glu::StructType inputStruct("Inputs"); 1645 for (vector<Symbol>::const_iterator symIter = spec.inputs.begin(); symIter != spec.inputs.end(); ++symIter) 1646 inputStruct.addMember(symIter->name.c_str(), symIter->varType); 1647 src << glu::declare(&inputStruct) << ";\n"; 1648 } 1649 1650 // Output struct 1651 { 1652 glu::StructType outputStruct("Outputs"); 1653 for (vector<Symbol>::const_iterator symIter = spec.outputs.begin(); symIter != spec.outputs.end(); ++symIter) 1654 outputStruct.addMember(symIter->name.c_str(), symIter->varType); 1655 src << glu::declare(&outputStruct) << ";\n"; 1656 } 1657 1658 src << "\n"; 1659 1660 if (!spec.inputs.empty()) 1661 { 1662 src << "layout(set = 0, binding = " << int(INPUT_BUFFER_BINDING) << ", std430) buffer InBuffer\n" 1663 << "{\n" 1664 << " Inputs inputs[];\n" 1665 << "};\n"; 1666 } 1667 1668 src << "layout(set = 0, binding = " << int(OUTPUT_BUFFER_BINDING) << ", std430) buffer OutBuffer\n" 1669 << "{\n" 1670 << " Outputs outputs[];\n" 1671 << "};\n" 1672 << "\n"; 1673 } 1674 1675 void BufferIoExecutor::generateExecBufferIo (std::ostream& src, const ShaderSpec& spec, const char* invocationNdxName) 1676 { 1677 for (vector<Symbol>::const_iterator symIter = spec.inputs.begin(); symIter != spec.inputs.end(); ++symIter) 1678 src << "\t" << glu::declare(symIter->varType, symIter->name) << " = inputs[" << invocationNdxName << "]." << symIter->name << ";\n"; 1679 1680 for (vector<Symbol>::const_iterator symIter = spec.outputs.begin(); symIter != spec.outputs.end(); ++symIter) 1681 src << "\t" << glu::declare(symIter->varType, symIter->name) << ";\n"; 1682 1683 src << "\n"; 1684 1685 { 1686 std::istringstream opSrc (spec.source); 1687 std::string line; 1688 1689 while (std::getline(opSrc, line)) 1690 src << "\t" << line << "\n"; 1691 } 1692 1693 src << "\n"; 1694 for (vector<Symbol>::const_iterator symIter = spec.outputs.begin(); symIter != spec.outputs.end(); ++symIter) 1695 src << "\toutputs[" << invocationNdxName << "]." << symIter->name << " = " << symIter->name << ";\n"; 1696 } 1697 1698 void BufferIoExecutor::copyToBuffer (const glu::VarType& varType, const VarLayout& layout, int numValues, const void* srcBasePtr, void* dstBasePtr) 1699 { 1700 if (varType.isBasicType()) 1701 { 1702 const glu::DataType basicType = varType.getBasicType(); 1703 const bool isMatrix = glu::isDataTypeMatrix(basicType); 1704 const int scalarSize = glu::getDataTypeScalarSize(basicType); 1705 const int numVecs = isMatrix ? glu::getDataTypeMatrixNumColumns(basicType) : 1; 1706 const int numComps = scalarSize / numVecs; 1707 1708 for (int elemNdx = 0; elemNdx < numValues; elemNdx++) 1709 { 1710 for (int vecNdx = 0; vecNdx < numVecs; vecNdx++) 1711 { 1712 const int srcOffset = (int)sizeof(deUint32) * (elemNdx * scalarSize + vecNdx * numComps); 1713 const int dstOffset = layout.offset + layout.stride * elemNdx + (isMatrix ? layout.matrixStride * vecNdx : 0); 1714 const deUint8* srcPtr = (const deUint8*)srcBasePtr + srcOffset; 1715 deUint8* dstPtr = (deUint8*)dstBasePtr + dstOffset; 1716 1717 deMemcpy(dstPtr, srcPtr, sizeof(deUint32) * numComps); 1718 } 1719 } 1720 } 1721 else 1722 throw tcu::InternalError("Unsupported type"); 1723 } 1724 1725 void BufferIoExecutor::copyFromBuffer (const glu::VarType& varType, const VarLayout& layout, int numValues, const void* srcBasePtr, void* dstBasePtr) 1726 { 1727 if (varType.isBasicType()) 1728 { 1729 const glu::DataType basicType = varType.getBasicType(); 1730 const bool isMatrix = glu::isDataTypeMatrix(basicType); 1731 const int scalarSize = glu::getDataTypeScalarSize(basicType); 1732 const int numVecs = isMatrix ? glu::getDataTypeMatrixNumColumns(basicType) : 1; 1733 const int numComps = scalarSize / numVecs; 1734 1735 for (int elemNdx = 0; elemNdx < numValues; elemNdx++) 1736 { 1737 for (int vecNdx = 0; vecNdx < numVecs; vecNdx++) 1738 { 1739 const int srcOffset = layout.offset + layout.stride * elemNdx + (isMatrix ? layout.matrixStride * vecNdx : 0); 1740 const int dstOffset = (int)sizeof(deUint32) * (elemNdx * scalarSize + vecNdx * numComps); 1741 const deUint8* srcPtr = (const deUint8*)srcBasePtr + srcOffset; 1742 deUint8* dstPtr = (deUint8*)dstBasePtr + dstOffset; 1743 1744 deMemcpy(dstPtr, srcPtr, sizeof(deUint32) * numComps); 1745 } 1746 } 1747 } 1748 else 1749 throw tcu::InternalError("Unsupported type"); 1750 } 1751 1752 void BufferIoExecutor::uploadInputBuffer (const void* const* inputPtrs, int numValues) 1753 { 1754 const VkDevice vkDevice = m_context.getDevice(); 1755 const DeviceInterface& vk = m_context.getDeviceInterface(); 1756 1757 const deUint32 inputStride = getLayoutStride(m_inputLayout); 1758 const int inputBufferSize = inputStride * numValues; 1759 1760 if (inputBufferSize == 0) 1761 return; // No inputs 1762 1763 DE_ASSERT(m_shaderSpec.inputs.size() == m_inputLayout.size()); 1764 for (size_t inputNdx = 0; inputNdx < m_shaderSpec.inputs.size(); ++inputNdx) 1765 { 1766 const glu::VarType& varType = m_shaderSpec.inputs[inputNdx].varType; 1767 const VarLayout& layout = m_inputLayout[inputNdx]; 1768 1769 copyToBuffer(varType, layout, numValues, inputPtrs[inputNdx], m_inputAlloc->getHostPtr()); 1770 } 1771 1772 flushMappedMemoryRange(vk, vkDevice, m_inputAlloc->getMemory(), m_inputAlloc->getOffset(), inputBufferSize); 1773 } 1774 1775 void BufferIoExecutor::readOutputBuffer (void* const* outputPtrs, int numValues) 1776 { 1777 const VkDevice vkDevice = m_context.getDevice(); 1778 const DeviceInterface& vk = m_context.getDeviceInterface(); 1779 1780 const deUint32 outputStride = getLayoutStride(m_outputLayout); 1781 const int outputBufferSize = numValues * outputStride; 1782 1783 DE_ASSERT(outputBufferSize > 0); // At least some outputs are required. 1784 1785 invalidateMappedMemoryRange(vk, vkDevice, m_outputAlloc->getMemory(), m_outputAlloc->getOffset(), outputBufferSize); 1786 1787 DE_ASSERT(m_shaderSpec.outputs.size() == m_outputLayout.size()); 1788 for (size_t outputNdx = 0; outputNdx < m_shaderSpec.outputs.size(); ++outputNdx) 1789 { 1790 const glu::VarType& varType = m_shaderSpec.outputs[outputNdx].varType; 1791 const VarLayout& layout = m_outputLayout[outputNdx]; 1792 1793 copyFromBuffer(varType, layout, numValues, m_outputAlloc->getHostPtr(), outputPtrs[outputNdx]); 1794 } 1795 } 1796 1797 void BufferIoExecutor::initBuffers (int numValues) 1798 { 1799 const deUint32 inputStride = getLayoutStride(m_inputLayout); 1800 const deUint32 outputStride = getLayoutStride(m_outputLayout); 1801 // Avoid creating zero-sized buffer/memory 1802 const size_t inputBufferSize = numValues * inputStride ? (numValues * inputStride) : 1; 1803 const size_t outputBufferSize = numValues * outputStride; 1804 1805 // Upload data to buffer 1806 const VkDevice vkDevice = m_context.getDevice(); 1807 const DeviceInterface& vk = m_context.getDeviceInterface(); 1808 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 1809 Allocator& memAlloc = m_context.getDefaultAllocator(); 1810 1811 const VkBufferCreateInfo inputBufferParams = 1812 { 1813 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; 1814 DE_NULL, // const void* pNext; 1815 0u, // VkBufferCreateFlags flags; 1816 inputBufferSize, // VkDeviceSize size; 1817 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, // VkBufferUsageFlags usage; 1818 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 1819 1u, // deUint32 queueFamilyCount; 1820 &queueFamilyIndex // const deUint32* pQueueFamilyIndices; 1821 }; 1822 1823 m_inputBuffer = createBuffer(vk, vkDevice, &inputBufferParams); 1824 m_inputAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_inputBuffer), MemoryRequirement::HostVisible); 1825 1826 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_inputBuffer, m_inputAlloc->getMemory(), m_inputAlloc->getOffset())); 1827 1828 const VkBufferCreateInfo outputBufferParams = 1829 { 1830 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; 1831 DE_NULL, // const void* pNext; 1832 0u, // VkBufferCreateFlags flags; 1833 outputBufferSize, // VkDeviceSize size; 1834 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, // VkBufferUsageFlags usage; 1835 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 1836 1u, // deUint32 queueFamilyCount; 1837 &queueFamilyIndex // const deUint32* pQueueFamilyIndices; 1838 }; 1839 1840 m_outputBuffer = createBuffer(vk, vkDevice, &outputBufferParams); 1841 m_outputAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_outputBuffer), MemoryRequirement::HostVisible); 1842 1843 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_outputBuffer, m_outputAlloc->getMemory(), m_outputAlloc->getOffset())); 1844 } 1845 1846 // ComputeShaderExecutor 1847 1848 class ComputeShaderExecutor : public BufferIoExecutor 1849 { 1850 public: 1851 ComputeShaderExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout); 1852 virtual ~ComputeShaderExecutor (void); 1853 1854 static void generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection); 1855 1856 virtual void execute (int numValues, const void* const* inputs, void* const* outputs, VkDescriptorSet extraResources); 1857 1858 protected: 1859 static std::string generateComputeShader (const ShaderSpec& spec); 1860 1861 private: 1862 const VkDescriptorSetLayout m_extraResourcesLayout; 1863 }; 1864 1865 ComputeShaderExecutor::ComputeShaderExecutor(Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 1866 : BufferIoExecutor (context, shaderSpec) 1867 , m_extraResourcesLayout (extraResourcesLayout) 1868 { 1869 } 1870 1871 ComputeShaderExecutor::~ComputeShaderExecutor (void) 1872 { 1873 } 1874 1875 std::string ComputeShaderExecutor::generateComputeShader (const ShaderSpec& spec) 1876 { 1877 std::ostringstream src; 1878 src << glu::getGLSLVersionDeclaration(spec.glslVersion) << "\n"; 1879 1880 if (!spec.globalDeclarations.empty()) 1881 src << spec.globalDeclarations << "\n"; 1882 1883 src << "layout(local_size_x = 1) in;\n" 1884 << "\n"; 1885 1886 declareBufferBlocks(src, spec); 1887 1888 src << "void main (void)\n" 1889 << "{\n" 1890 << " uint invocationNdx = gl_NumWorkGroups.x*gl_NumWorkGroups.y*gl_WorkGroupID.z\n" 1891 << " + gl_NumWorkGroups.x*gl_WorkGroupID.y + gl_WorkGroupID.x;\n"; 1892 1893 generateExecBufferIo(src, spec, "invocationNdx"); 1894 1895 src << "}\n"; 1896 1897 return src.str(); 1898 } 1899 1900 void ComputeShaderExecutor::generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection) 1901 { 1902 programCollection.glslSources.add("compute") << glu::ComputeSource(generateComputeShader(shaderSpec)) << shaderSpec.buildOptions; 1903 } 1904 1905 void ComputeShaderExecutor::execute (int numValues, const void* const* inputs, void* const* outputs, VkDescriptorSet extraResources) 1906 { 1907 const VkDevice vkDevice = m_context.getDevice(); 1908 const DeviceInterface& vk = m_context.getDeviceInterface(); 1909 const VkQueue queue = m_context.getUniversalQueue(); 1910 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 1911 1912 DescriptorPoolBuilder descriptorPoolBuilder; 1913 DescriptorSetLayoutBuilder descriptorSetLayoutBuilder; 1914 1915 Move<VkShaderModule> computeShaderModule; 1916 Move<VkPipeline> computePipeline; 1917 Move<VkPipelineLayout> pipelineLayout; 1918 Move<VkCommandPool> cmdPool; 1919 Move<VkDescriptorPool> descriptorPool; 1920 Move<VkDescriptorSetLayout> descriptorSetLayout; 1921 Move<VkDescriptorSet> descriptorSet; 1922 const deUint32 numDescriptorSets = (m_extraResourcesLayout != 0) ? 2u : 1u; 1923 Move<VkFence> fence; 1924 1925 DE_ASSERT((m_extraResourcesLayout != 0) == (extraResources != 0)); 1926 1927 initBuffers(numValues); 1928 1929 // Setup input buffer & copy data 1930 uploadInputBuffer(inputs, numValues); 1931 1932 // Create command pool 1933 cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex); 1934 1935 // Create command buffer 1936 const VkCommandBufferBeginInfo cmdBufferBeginInfo = 1937 { 1938 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; 1939 DE_NULL, // const void* pNext; 1940 0u, // VkCmdBufferOptimizeFlags flags; 1941 (const VkCommandBufferInheritanceInfo*)DE_NULL, 1942 }; 1943 1944 descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT); 1945 descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); 1946 descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT); 1947 descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); 1948 1949 descriptorSetLayout = descriptorSetLayoutBuilder.build(vk, vkDevice); 1950 descriptorPool = descriptorPoolBuilder.build(vk, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u); 1951 1952 const VkDescriptorSetAllocateInfo allocInfo = 1953 { 1954 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 1955 DE_NULL, 1956 *descriptorPool, 1957 1u, 1958 &*descriptorSetLayout 1959 }; 1960 1961 descriptorSet = allocateDescriptorSet(vk, vkDevice, &allocInfo); 1962 1963 // Create pipeline layout 1964 { 1965 const VkDescriptorSetLayout descriptorSetLayouts[] = 1966 { 1967 *descriptorSetLayout, 1968 m_extraResourcesLayout 1969 }; 1970 const VkPipelineLayoutCreateInfo pipelineLayoutParams = 1971 { 1972 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 1973 DE_NULL, // const void* pNext; 1974 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags; 1975 numDescriptorSets, // deUint32 CdescriptorSetCount; 1976 descriptorSetLayouts, // const VkDescriptorSetLayout* pSetLayouts; 1977 0u, // deUint32 pushConstantRangeCount; 1978 DE_NULL // const VkPushConstantRange* pPushConstantRanges; 1979 }; 1980 1981 pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams); 1982 } 1983 1984 // Create shaders 1985 { 1986 computeShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("compute"), 0); 1987 } 1988 1989 // create pipeline 1990 { 1991 const VkPipelineShaderStageCreateInfo shaderStageParams[1] = 1992 { 1993 { 1994 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 1995 DE_NULL, // const void* pNext; 1996 (VkPipelineShaderStageCreateFlags)0u, // VkPipelineShaderStageCreateFlags flags; 1997 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagsBit stage; 1998 *computeShaderModule, // VkShaderModule shader; 1999 "main", // const char* pName; 2000 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 2001 } 2002 }; 2003 2004 const VkComputePipelineCreateInfo computePipelineParams = 2005 { 2006 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType; 2007 DE_NULL, // const void* pNext; 2008 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags; 2009 *shaderStageParams, // VkPipelineShaderStageCreateInfo cs; 2010 *pipelineLayout, // VkPipelineLayout layout; 2011 0u, // VkPipeline basePipelineHandle; 2012 0u, // int32_t basePipelineIndex; 2013 }; 2014 2015 computePipeline = createComputePipeline(vk, vkDevice, DE_NULL, &computePipelineParams); 2016 } 2017 2018 // Create fence 2019 fence = createFence(vk, vkDevice); 2020 2021 const int maxValuesPerInvocation = m_context.getDeviceProperties().limits.maxComputeWorkGroupSize[0]; 2022 int curOffset = 0; 2023 const deUint32 inputStride = getInputStride(); 2024 const deUint32 outputStride = getOutputStride(); 2025 2026 while (curOffset < numValues) 2027 { 2028 Move<VkCommandBuffer> cmdBuffer; 2029 const int numToExec = de::min(maxValuesPerInvocation, numValues-curOffset); 2030 2031 // Update descriptors 2032 { 2033 DescriptorSetUpdateBuilder descriptorSetUpdateBuilder; 2034 2035 const VkDescriptorBufferInfo outputDescriptorBufferInfo = 2036 { 2037 *m_outputBuffer, // VkBuffer buffer; 2038 curOffset * outputStride, // VkDeviceSize offset; 2039 numToExec * outputStride // VkDeviceSize range; 2040 }; 2041 2042 descriptorSetUpdateBuilder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding((deUint32)OUTPUT_BUFFER_BINDING), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &outputDescriptorBufferInfo); 2043 2044 if (inputStride) 2045 { 2046 const VkDescriptorBufferInfo inputDescriptorBufferInfo = 2047 { 2048 *m_inputBuffer, // VkBuffer buffer; 2049 curOffset * inputStride, // VkDeviceSize offset; 2050 numToExec * inputStride // VkDeviceSize range; 2051 }; 2052 2053 descriptorSetUpdateBuilder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding((deUint32)INPUT_BUFFER_BINDING), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &inputDescriptorBufferInfo); 2054 } 2055 2056 descriptorSetUpdateBuilder.update(vk, vkDevice); 2057 } 2058 2059 cmdBuffer = allocateCommandBuffer(vk, vkDevice, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); 2060 VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo)); 2061 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *computePipeline); 2062 2063 { 2064 const VkDescriptorSet descriptorSets[] = { *descriptorSet, extraResources }; 2065 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, numDescriptorSets, descriptorSets, 0u, DE_NULL); 2066 } 2067 2068 vk.cmdDispatch(*cmdBuffer, numToExec, 1, 1); 2069 2070 VK_CHECK(vk.endCommandBuffer(*cmdBuffer)); 2071 2072 curOffset += numToExec; 2073 2074 // Execute 2075 { 2076 VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get())); 2077 2078 const VkSubmitInfo submitInfo = 2079 { 2080 VK_STRUCTURE_TYPE_SUBMIT_INFO, 2081 DE_NULL, 2082 0u, 2083 (const VkSemaphore*)DE_NULL, 2084 (const VkPipelineStageFlags*)DE_NULL, 2085 1u, 2086 &cmdBuffer.get(), 2087 0u, 2088 (const VkSemaphore*)DE_NULL, 2089 }; 2090 2091 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence)); 2092 VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity*/)); 2093 } 2094 } 2095 2096 // Read back data 2097 readOutputBuffer(outputs, numValues); 2098 } 2099 2100 // Tessellation utils 2101 2102 static std::string generateVertexShaderForTess (void) 2103 { 2104 std::ostringstream src; 2105 src << "#version 310 es\n" 2106 << "void main (void)\n{\n" 2107 << " gl_Position = vec4(gl_VertexIndex/2, gl_VertexIndex%2, 0.0, 1.0);\n" 2108 << "}\n"; 2109 2110 return src.str(); 2111 } 2112 2113 class TessellationExecutor : public BufferIoExecutor 2114 { 2115 public: 2116 TessellationExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout); 2117 virtual ~TessellationExecutor (void); 2118 2119 void renderTess (deUint32 numValues, deUint32 vertexCount, deUint32 patchControlPoints, VkDescriptorSet extraResources); 2120 2121 private: 2122 const VkDescriptorSetLayout m_extraResourcesLayout; 2123 }; 2124 2125 TessellationExecutor::TessellationExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 2126 : BufferIoExecutor (context, shaderSpec) 2127 , m_extraResourcesLayout (extraResourcesLayout) 2128 { 2129 const VkPhysicalDeviceFeatures& features = context.getDeviceFeatures(); 2130 2131 if (!features.tessellationShader) 2132 TCU_THROW(NotSupportedError, "Tessellation shader is not supported by device"); 2133 } 2134 2135 TessellationExecutor::~TessellationExecutor (void) 2136 { 2137 } 2138 2139 void TessellationExecutor::renderTess (deUint32 numValues, deUint32 vertexCount, deUint32 patchControlPoints, VkDescriptorSet extraResources) 2140 { 2141 const size_t inputBufferSize = numValues * getInputStride(); 2142 const VkDevice vkDevice = m_context.getDevice(); 2143 const DeviceInterface& vk = m_context.getDeviceInterface(); 2144 const VkQueue queue = m_context.getUniversalQueue(); 2145 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 2146 Allocator& memAlloc = m_context.getDefaultAllocator(); 2147 2148 const tcu::UVec2 renderSize (DEFAULT_RENDER_WIDTH, DEFAULT_RENDER_HEIGHT); 2149 2150 Move<VkImage> colorImage; 2151 de::MovePtr<Allocation> colorImageAlloc; 2152 VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM; 2153 Move<VkImageView> colorImageView; 2154 2155 Move<VkRenderPass> renderPass; 2156 Move<VkFramebuffer> framebuffer; 2157 Move<VkPipelineLayout> pipelineLayout; 2158 Move<VkPipeline> graphicsPipeline; 2159 2160 Move<VkShaderModule> vertexShaderModule; 2161 Move<VkShaderModule> tessControlShaderModule; 2162 Move<VkShaderModule> tessEvalShaderModule; 2163 Move<VkShaderModule> fragmentShaderModule; 2164 2165 Move<VkCommandPool> cmdPool; 2166 Move<VkCommandBuffer> cmdBuffer; 2167 2168 Move<VkFence> fence; 2169 2170 Move<VkDescriptorPool> descriptorPool; 2171 Move<VkDescriptorSetLayout> descriptorSetLayout; 2172 Move<VkDescriptorSet> descriptorSet; 2173 const deUint32 numDescriptorSets = (m_extraResourcesLayout != 0) ? 2u : 1u; 2174 2175 DE_ASSERT((m_extraResourcesLayout != 0) == (extraResources != 0)); 2176 2177 // Create color image 2178 { 2179 const VkImageCreateInfo colorImageParams = 2180 { 2181 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; 2182 DE_NULL, // const void* pNext; 2183 0u, // VkImageCreateFlags flags; 2184 VK_IMAGE_TYPE_2D, // VkImageType imageType; 2185 colorFormat, // VkFormat format; 2186 { renderSize.x(), renderSize.y(), 1u }, // VkExtent3D extent; 2187 1u, // deUint32 mipLevels; 2188 1u, // deUint32 arraySize; 2189 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 2190 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; 2191 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage; 2192 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; 2193 1u, // deUint32 queueFamilyCount; 2194 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices; 2195 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout; 2196 }; 2197 2198 colorImage = createImage(vk, vkDevice, &colorImageParams); 2199 2200 // Allocate and bind color image memory 2201 colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *colorImage), MemoryRequirement::Any); 2202 VK_CHECK(vk.bindImageMemory(vkDevice, *colorImage, colorImageAlloc->getMemory(), colorImageAlloc->getOffset())); 2203 } 2204 2205 // Create color attachment view 2206 { 2207 const VkImageViewCreateInfo colorImageViewParams = 2208 { 2209 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType; 2210 DE_NULL, // const void* pNext; 2211 0u, // VkImageViewCreateFlags flags; 2212 *colorImage, // VkImage image; 2213 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType; 2214 colorFormat, // VkFormat format; 2215 { 2216 VK_COMPONENT_SWIZZLE_R, // VkComponentSwizzle r; 2217 VK_COMPONENT_SWIZZLE_G, // VkComponentSwizzle g; 2218 VK_COMPONENT_SWIZZLE_B, // VkComponentSwizzle b; 2219 VK_COMPONENT_SWIZZLE_A // VkComponentSwizzle a; 2220 }, // VkComponentsMapping components; 2221 { 2222 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask; 2223 0u, // deUint32 baseMipLevel; 2224 1u, // deUint32 mipLevels; 2225 0u, // deUint32 baseArraylayer; 2226 1u // deUint32 layerCount; 2227 } // VkImageSubresourceRange subresourceRange; 2228 }; 2229 2230 colorImageView = createImageView(vk, vkDevice, &colorImageViewParams); 2231 } 2232 2233 // Create render pass 2234 { 2235 const VkAttachmentDescription colorAttachmentDescription = 2236 { 2237 0u, // VkAttachmentDescriptorFlags flags; 2238 colorFormat, // VkFormat format; 2239 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 2240 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; 2241 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; 2242 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; 2243 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; 2244 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; 2245 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout 2246 }; 2247 2248 const VkAttachmentDescription attachments[1] = 2249 { 2250 colorAttachmentDescription 2251 }; 2252 2253 const VkAttachmentReference colorAttachmentReference = 2254 { 2255 0u, // deUint32 attachment; 2256 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; 2257 }; 2258 2259 const VkSubpassDescription subpassDescription = 2260 { 2261 0u, // VkSubpassDescriptionFlags flags; 2262 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; 2263 0u, // deUint32 inputCount; 2264 DE_NULL, // const VkAttachmentReference* pInputAttachments; 2265 1u, // deUint32 colorCount; 2266 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments; 2267 DE_NULL, // const VkAttachmentReference* pResolveAttachments; 2268 DE_NULL, // VkAttachmentReference depthStencilAttachment; 2269 0u, // deUint32 preserveCount; 2270 DE_NULL // const VkAttachmentReference* pPreserveAttachments; 2271 }; 2272 2273 const VkRenderPassCreateInfo renderPassParams = 2274 { 2275 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; 2276 DE_NULL, // const void* pNext; 2277 0u, // VkRenderPassCreateFlags flags; 2278 1u, // deUint32 attachmentCount; 2279 attachments, // const VkAttachmentDescription* pAttachments; 2280 1u, // deUint32 subpassCount; 2281 &subpassDescription, // const VkSubpassDescription* pSubpasses; 2282 0u, // deUint32 dependencyCount; 2283 DE_NULL // const VkSubpassDependency* pDependencies; 2284 }; 2285 2286 renderPass = createRenderPass(vk, vkDevice, &renderPassParams); 2287 } 2288 2289 // Create framebuffer 2290 { 2291 const VkFramebufferCreateInfo framebufferParams = 2292 { 2293 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; 2294 DE_NULL, // const void* pNext; 2295 0u, // VkFramebufferCreateFlags flags; 2296 *renderPass, // VkRenderPass renderPass; 2297 1u, // deUint32 attachmentCount; 2298 &*colorImageView, // const VkAttachmentBindInfo* pAttachments; 2299 (deUint32)renderSize.x(), // deUint32 width; 2300 (deUint32)renderSize.y(), // deUint32 height; 2301 1u // deUint32 layers; 2302 }; 2303 2304 framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams); 2305 } 2306 2307 // Create descriptors 2308 { 2309 DescriptorPoolBuilder descriptorPoolBuilder; 2310 DescriptorSetLayoutBuilder descriptorSetLayoutBuilder; 2311 2312 descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_ALL); 2313 descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); 2314 descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_ALL); 2315 descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); 2316 2317 descriptorSetLayout = descriptorSetLayoutBuilder.build(vk, vkDevice); 2318 descriptorPool = descriptorPoolBuilder.build(vk, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u); 2319 2320 const VkDescriptorSetAllocateInfo allocInfo = 2321 { 2322 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 2323 DE_NULL, 2324 *descriptorPool, 2325 1u, 2326 &*descriptorSetLayout 2327 }; 2328 2329 descriptorSet = allocateDescriptorSet(vk, vkDevice, &allocInfo); 2330 // Update descriptors 2331 { 2332 DescriptorSetUpdateBuilder descriptorSetUpdateBuilder; 2333 const VkDescriptorBufferInfo outputDescriptorBufferInfo = 2334 { 2335 *m_outputBuffer, // VkBuffer buffer; 2336 0u, // VkDeviceSize offset; 2337 VK_WHOLE_SIZE // VkDeviceSize range; 2338 }; 2339 2340 descriptorSetUpdateBuilder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding((deUint32)OUTPUT_BUFFER_BINDING), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &outputDescriptorBufferInfo); 2341 2342 VkDescriptorBufferInfo inputDescriptorBufferInfo = 2343 { 2344 0, // VkBuffer buffer; 2345 0u, // VkDeviceSize offset; 2346 VK_WHOLE_SIZE // VkDeviceSize range; 2347 }; 2348 2349 if (inputBufferSize > 0) 2350 { 2351 inputDescriptorBufferInfo.buffer = *m_inputBuffer; 2352 2353 descriptorSetUpdateBuilder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding((deUint32)INPUT_BUFFER_BINDING), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &inputDescriptorBufferInfo); 2354 } 2355 2356 descriptorSetUpdateBuilder.update(vk, vkDevice); 2357 } 2358 } 2359 2360 // Create pipeline layout 2361 { 2362 const VkDescriptorSetLayout descriptorSetLayouts[] = 2363 { 2364 *descriptorSetLayout, 2365 m_extraResourcesLayout 2366 }; 2367 const VkPipelineLayoutCreateInfo pipelineLayoutParams = 2368 { 2369 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; 2370 DE_NULL, // const void* pNext; 2371 (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags; 2372 numDescriptorSets, // deUint32 descriptorSetCount; 2373 descriptorSetLayouts, // const VkDescriptorSetLayout* pSetLayouts; 2374 0u, // deUint32 pushConstantRangeCount; 2375 DE_NULL // const VkPushConstantRange* pPushConstantRanges; 2376 }; 2377 2378 pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams); 2379 } 2380 2381 // Create shader modules 2382 { 2383 vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("vert"), 0); 2384 tessControlShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("tess_control"), 0); 2385 tessEvalShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("tess_eval"), 0); 2386 fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("frag"), 0); 2387 } 2388 2389 // Create pipeline 2390 { 2391 const VkPipelineShaderStageCreateInfo shaderStageParams[4] = 2392 { 2393 { 2394 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 2395 DE_NULL, // const void* pNext; 2396 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 2397 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBit stage; 2398 *vertexShaderModule, // VkShaderModule shader; 2399 "main", // const char* pName; 2400 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 2401 }, 2402 { 2403 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 2404 DE_NULL, // const void* pNext; 2405 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 2406 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, // VkShaderStageFlagBit stage; 2407 *tessControlShaderModule, // VkShaderModule shader; 2408 "main", // const char* pName; 2409 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 2410 }, 2411 { 2412 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 2413 DE_NULL, // const void* pNext; 2414 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 2415 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, // VkShaderStageFlagBit stage; 2416 *tessEvalShaderModule, // VkShaderModule shader; 2417 "main", // const char* pName; 2418 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 2419 }, 2420 { 2421 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; 2422 DE_NULL, // const void* pNext; 2423 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 2424 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBit stage; 2425 *fragmentShaderModule, // VkShaderModule shader; 2426 "main", // const char* pName; 2427 DE_NULL // const VkSpecializationInfo* pSpecializationInfo; 2428 } 2429 }; 2430 2431 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams = 2432 { 2433 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; 2434 DE_NULL, // const void* pNext; 2435 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags; 2436 0u, // deUint32 bindingCount; 2437 DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions; 2438 0u, // deUint32 attributeCount; 2439 DE_NULL, // const VkVertexInputAttributeDescription* pvertexAttributeDescriptions; 2440 }; 2441 2442 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams = 2443 { 2444 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; 2445 DE_NULL, // const void* pNext; 2446 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; 2447 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, // VkPrimitiveTopology topology; 2448 DE_FALSE // VkBool32 primitiveRestartEnable; 2449 }; 2450 2451 struct VkPipelineTessellationStateCreateInfo tessellationStateParams = 2452 { 2453 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType; 2454 DE_NULL, // const void* pNext; 2455 (VkPipelineTessellationStateCreateFlags)0, // VkPipelineTessellationStateCreateFlags flags; 2456 patchControlPoints // uint32_t patchControlPoints; 2457 }; 2458 2459 const VkViewport viewport = 2460 { 2461 0.0f, // float originX; 2462 0.0f, // float originY; 2463 (float)renderSize.x(), // float width; 2464 (float)renderSize.y(), // float height; 2465 0.0f, // float minDepth; 2466 1.0f // float maxDepth; 2467 }; 2468 2469 const VkRect2D scissor = 2470 { 2471 { 2472 0u, // deUint32 x; 2473 0u, // deUint32 y; 2474 }, // VkOffset2D offset; 2475 { 2476 renderSize.x(), // deUint32 width; 2477 renderSize.y(), // deUint32 height; 2478 }, // VkExtent2D extent; 2479 }; 2480 2481 const VkPipelineViewportStateCreateInfo viewportStateParams = 2482 { 2483 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; 2484 DE_NULL, // const void* pNext; 2485 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewPortStateCreateFlags flags; 2486 1u, // deUint32 viewportCount; 2487 &viewport, // const VkViewport* pViewports; 2488 1u, // deUint32 scissorsCount; 2489 &scissor // const VkRect2D* pScissors; 2490 }; 2491 2492 const VkPipelineRasterizationStateCreateInfo rasterStateParams = 2493 { 2494 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType; 2495 DE_NULL, // const void* pNext; 2496 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStageCreateFlags flags; 2497 VK_FALSE, // VkBool32 depthClipEnable; 2498 VK_FALSE, // VkBool32 rasterizerDiscardEnable; 2499 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode; 2500 VK_CULL_MODE_NONE, // VkCullMode cullMode; 2501 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace; 2502 VK_FALSE, // VkBool32 depthBiasEnable; 2503 0.0f, // float depthBias; 2504 0.0f, // float depthBiasClamp; 2505 0.0f, // float slopeScaledDepthBias; 2506 1.0f // float lineWidth; 2507 }; 2508 2509 const VkPipelineMultisampleStateCreateInfo multisampleStateParams = 2510 { 2511 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; 2512 DE_NULL, // const void* pNext; 2513 0u, // VkPipelineMultisampleStateCreateFlags flags; 2514 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples; 2515 VK_FALSE, // VkBool32 sampleShadingEnable; 2516 0.0f, // float minSampleShading; 2517 DE_NULL, // const VkSampleMask* pSampleMask; 2518 VK_FALSE, // VkBool32 alphaToCoverageEnable; 2519 VK_FALSE // VkBool32 alphaToOneEnable; 2520 }; 2521 2522 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState = 2523 { 2524 VK_FALSE, // VkBool32 blendEnable; 2525 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcBlendColor; 2526 VK_BLEND_FACTOR_ZERO, // VkBlendFactor destBlendColor; 2527 VK_BLEND_OP_ADD, // VkBlendOp blendOpColor; 2528 VK_BLEND_FACTOR_ONE, // VkBlendFactor srcBlendAlpha; 2529 VK_BLEND_FACTOR_ZERO, // VkBlendFactor destBlendAlpha; 2530 VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha; 2531 (VK_COLOR_COMPONENT_R_BIT | 2532 VK_COLOR_COMPONENT_G_BIT | 2533 VK_COLOR_COMPONENT_B_BIT | 2534 VK_COLOR_COMPONENT_A_BIT) // VkColorComponentFlags colorWriteMask; 2535 }; 2536 2537 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams = 2538 { 2539 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; 2540 DE_NULL, // const void* pNext; 2541 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags 2542 VK_FALSE, // VkBool32 logicOpEnable; 2543 VK_LOGIC_OP_COPY, // VkLogicOp logicOp; 2544 1u, // deUint32 attachmentCount; 2545 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments; 2546 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConst[4]; 2547 }; 2548 2549 const VkGraphicsPipelineCreateInfo graphicsPipelineParams = 2550 { 2551 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; 2552 DE_NULL, // const void* pNext; 2553 0u, // VkPipelineCreateFlags flags; 2554 4u, // deUint32 stageCount; 2555 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages; 2556 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 2557 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 2558 &tessellationStateParams, // const VkPipelineTessellationStateCreateInfo* pTessellationState; 2559 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState; 2560 &rasterStateParams, // const VkPipelineRasterStateCreateInfo* pRasterState; 2561 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 2562 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 2563 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 2564 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState; 2565 *pipelineLayout, // VkPipelineLayout layout; 2566 *renderPass, // VkRenderPass renderPass; 2567 0u, // deUint32 subpass; 2568 0u, // VkPipeline basePipelineHandle; 2569 0u // deInt32 basePipelineIndex; 2570 }; 2571 2572 graphicsPipeline = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams); 2573 } 2574 2575 // Create command pool 2576 cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex); 2577 2578 // Create command buffer 2579 { 2580 const VkCommandBufferBeginInfo cmdBufferBeginInfo = 2581 { 2582 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType; 2583 DE_NULL, // const void* pNext; 2584 0u, // VkCmdBufferOptimizeFlags flags; 2585 (const VkCommandBufferInheritanceInfo*)DE_NULL, 2586 }; 2587 2588 const VkClearValue clearValues[1] = 2589 { 2590 getDefaultClearColor() 2591 }; 2592 2593 const VkRenderPassBeginInfo renderPassBeginInfo = 2594 { 2595 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType; 2596 DE_NULL, // const void* pNext; 2597 *renderPass, // VkRenderPass renderPass; 2598 *framebuffer, // VkFramebuffer framebuffer; 2599 { { 0, 0 }, { renderSize.x(), renderSize.y() } }, // VkRect2D renderArea; 2600 1, // deUint32 attachmentCount; 2601 clearValues // const VkClearValue* pClearValues; 2602 }; 2603 2604 cmdBuffer = allocateCommandBuffer(vk, vkDevice, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY); 2605 2606 VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo)); 2607 2608 vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); 2609 2610 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline); 2611 2612 { 2613 const VkDescriptorSet descriptorSets[] = { *descriptorSet, extraResources }; 2614 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, numDescriptorSets, descriptorSets, 0u, DE_NULL); 2615 } 2616 2617 vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0); 2618 2619 vk.cmdEndRenderPass(*cmdBuffer); 2620 VK_CHECK(vk.endCommandBuffer(*cmdBuffer)); 2621 } 2622 2623 // Create fence 2624 fence = createFence(vk, vkDevice); 2625 2626 // Execute Draw 2627 { 2628 VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get())); 2629 const VkSubmitInfo submitInfo = 2630 { 2631 VK_STRUCTURE_TYPE_SUBMIT_INFO, 2632 DE_NULL, 2633 0u, 2634 (const VkSemaphore*)0, 2635 (const VkPipelineStageFlags*)DE_NULL, 2636 1u, 2637 &cmdBuffer.get(), 2638 0u, 2639 (const VkSemaphore*)0, 2640 }; 2641 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence)); 2642 VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity*/)); 2643 } 2644 } 2645 2646 // TessControlExecutor 2647 2648 class TessControlExecutor : public TessellationExecutor 2649 { 2650 public: 2651 TessControlExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout); 2652 virtual ~TessControlExecutor (void); 2653 2654 static void generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection); 2655 2656 virtual void execute (int numValues, const void* const* inputs, void* const* outputs, VkDescriptorSet extraResources); 2657 2658 protected: 2659 static std::string generateTessControlShader (const ShaderSpec& shaderSpec); 2660 }; 2661 2662 TessControlExecutor::TessControlExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 2663 : TessellationExecutor(context, shaderSpec, extraResourcesLayout) 2664 { 2665 } 2666 2667 TessControlExecutor::~TessControlExecutor (void) 2668 { 2669 } 2670 2671 std::string TessControlExecutor::generateTessControlShader (const ShaderSpec& shaderSpec) 2672 { 2673 std::ostringstream src; 2674 src << glu::getGLSLVersionDeclaration(shaderSpec.glslVersion) << "\n"; 2675 2676 if (shaderSpec.glslVersion == glu::GLSL_VERSION_310_ES) 2677 src << "#extension GL_EXT_tessellation_shader : require\n\n"; 2678 2679 if (!shaderSpec.globalDeclarations.empty()) 2680 src << shaderSpec.globalDeclarations << "\n"; 2681 2682 src << "\nlayout(vertices = 1) out;\n\n"; 2683 2684 declareBufferBlocks(src, shaderSpec); 2685 2686 src << "void main (void)\n{\n"; 2687 2688 for (int ndx = 0; ndx < 2; ndx++) 2689 src << "\tgl_TessLevelInner[" << ndx << "] = 1.0;\n"; 2690 2691 for (int ndx = 0; ndx < 4; ndx++) 2692 src << "\tgl_TessLevelOuter[" << ndx << "] = 1.0;\n"; 2693 2694 src << "\n" 2695 << "\thighp uint invocationId = uint(gl_PrimitiveID);\n"; 2696 2697 generateExecBufferIo(src, shaderSpec, "invocationId"); 2698 2699 src << "}\n"; 2700 2701 return src.str(); 2702 } 2703 2704 static std::string generateEmptyTessEvalShader () 2705 { 2706 std::ostringstream src; 2707 2708 src << "#version 310 es\n" 2709 "#extension GL_EXT_tessellation_shader : require\n\n"; 2710 2711 src << "layout(triangles, ccw) in;\n"; 2712 2713 src << "\nvoid main (void)\n{\n" 2714 << "\tgl_Position = vec4(gl_TessCoord.xy, 0.0, 1.0);\n" 2715 << "}\n"; 2716 2717 return src.str(); 2718 } 2719 2720 void TessControlExecutor::generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection) 2721 { 2722 programCollection.glslSources.add("vert") << glu::VertexSource(generateVertexShaderForTess()) << shaderSpec.buildOptions; 2723 programCollection.glslSources.add("tess_control") << glu::TessellationControlSource(generateTessControlShader(shaderSpec)) << shaderSpec.buildOptions; 2724 programCollection.glslSources.add("tess_eval") << glu::TessellationEvaluationSource(generateEmptyTessEvalShader()) << shaderSpec.buildOptions; 2725 programCollection.glslSources.add("frag") << glu::FragmentSource(generateEmptyFragmentSource()) << shaderSpec.buildOptions; 2726 } 2727 2728 void TessControlExecutor::execute (int numValues, const void* const* inputs, void* const* outputs, VkDescriptorSet extraResources) 2729 { 2730 const deUint32 patchSize = 3; 2731 2732 initBuffers(numValues); 2733 2734 // Setup input buffer & copy data 2735 uploadInputBuffer(inputs, numValues); 2736 2737 renderTess(numValues, patchSize * numValues, patchSize, extraResources); 2738 2739 // Read back data 2740 readOutputBuffer(outputs, numValues); 2741 } 2742 2743 // TessEvaluationExecutor 2744 2745 class TessEvaluationExecutor : public TessellationExecutor 2746 { 2747 public: 2748 TessEvaluationExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout); 2749 virtual ~TessEvaluationExecutor (void); 2750 2751 static void generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection); 2752 2753 virtual void execute (int numValues, const void* const* inputs, void* const* outputs, VkDescriptorSet extraResources); 2754 2755 protected: 2756 static std::string generateTessEvalShader (const ShaderSpec& shaderSpec); 2757 }; 2758 2759 TessEvaluationExecutor::TessEvaluationExecutor (Context& context, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 2760 : TessellationExecutor (context, shaderSpec, extraResourcesLayout) 2761 { 2762 } 2763 2764 TessEvaluationExecutor::~TessEvaluationExecutor (void) 2765 { 2766 } 2767 2768 static std::string generatePassthroughTessControlShader (void) 2769 { 2770 std::ostringstream src; 2771 2772 src << "#version 310 es\n" 2773 "#extension GL_EXT_tessellation_shader : require\n\n"; 2774 2775 src << "layout(vertices = 1) out;\n\n"; 2776 2777 src << "void main (void)\n{\n"; 2778 2779 for (int ndx = 0; ndx < 2; ndx++) 2780 src << "\tgl_TessLevelInner[" << ndx << "] = 1.0;\n"; 2781 2782 for (int ndx = 0; ndx < 4; ndx++) 2783 src << "\tgl_TessLevelOuter[" << ndx << "] = 1.0;\n"; 2784 2785 src << "}\n"; 2786 2787 return src.str(); 2788 } 2789 2790 std::string TessEvaluationExecutor::generateTessEvalShader (const ShaderSpec& shaderSpec) 2791 { 2792 std::ostringstream src; 2793 2794 src << glu::getGLSLVersionDeclaration(shaderSpec.glslVersion) << "\n"; 2795 2796 if (shaderSpec.glslVersion == glu::GLSL_VERSION_310_ES) 2797 src << "#extension GL_EXT_tessellation_shader : require\n\n"; 2798 2799 if (!shaderSpec.globalDeclarations.empty()) 2800 src << shaderSpec.globalDeclarations << "\n"; 2801 2802 src << "\n"; 2803 2804 src << "layout(isolines, equal_spacing) in;\n\n"; 2805 2806 declareBufferBlocks(src, shaderSpec); 2807 2808 src << "void main (void)\n{\n" 2809 << "\tgl_Position = vec4(gl_TessCoord.x, 0.0, 0.0, 1.0);\n" 2810 << "\thighp uint invocationId = uint(gl_PrimitiveID)*2u + (gl_TessCoord.x > 0.5 ? 1u : 0u);\n"; 2811 2812 generateExecBufferIo(src, shaderSpec, "invocationId"); 2813 2814 src << "}\n"; 2815 2816 return src.str(); 2817 } 2818 2819 void TessEvaluationExecutor::generateSources (const ShaderSpec& shaderSpec, SourceCollections& programCollection) 2820 { 2821 programCollection.glslSources.add("vert") << glu::VertexSource(generateVertexShaderForTess()) << shaderSpec.buildOptions; 2822 programCollection.glslSources.add("tess_control") << glu::TessellationControlSource(generatePassthroughTessControlShader()) << shaderSpec.buildOptions; 2823 programCollection.glslSources.add("tess_eval") << glu::TessellationEvaluationSource(generateTessEvalShader(shaderSpec)) << shaderSpec.buildOptions; 2824 programCollection.glslSources.add("frag") << glu::FragmentSource(generateEmptyFragmentSource()) << shaderSpec.buildOptions; 2825 } 2826 2827 void TessEvaluationExecutor::execute (int numValues, const void* const* inputs, void* const* outputs, VkDescriptorSet extraResources) 2828 { 2829 const int patchSize = 2; 2830 const int alignedValues = deAlign32(numValues, patchSize); 2831 2832 // Initialize buffers with aligned value count to make room for padding 2833 initBuffers(alignedValues); 2834 2835 // Setup input buffer & copy data 2836 uploadInputBuffer(inputs, numValues); 2837 2838 renderTess((deUint32)alignedValues, (deUint32)alignedValues, (deUint32)patchSize, extraResources); 2839 2840 // Read back data 2841 readOutputBuffer(outputs, numValues); 2842 } 2843 2844 } // anonymous 2845 2846 // ShaderExecutor 2847 2848 ShaderExecutor::~ShaderExecutor (void) 2849 { 2850 } 2851 2852 // Utilities 2853 2854 void generateSources (glu::ShaderType shaderType, const ShaderSpec& shaderSpec, vk::SourceCollections& dst) 2855 { 2856 switch (shaderType) 2857 { 2858 case glu::SHADERTYPE_VERTEX: VertexShaderExecutor::generateSources (shaderSpec, dst); break; 2859 case glu::SHADERTYPE_TESSELLATION_CONTROL: TessControlExecutor::generateSources (shaderSpec, dst); break; 2860 case glu::SHADERTYPE_TESSELLATION_EVALUATION: TessEvaluationExecutor::generateSources (shaderSpec, dst); break; 2861 case glu::SHADERTYPE_GEOMETRY: GeometryShaderExecutor::generateSources (shaderSpec, dst); break; 2862 case glu::SHADERTYPE_FRAGMENT: FragmentShaderExecutor::generateSources (shaderSpec, dst); break; 2863 case glu::SHADERTYPE_COMPUTE: ComputeShaderExecutor::generateSources (shaderSpec, dst); break; 2864 default: 2865 TCU_THROW(InternalError, "Unsupported shader type"); 2866 } 2867 } 2868 2869 ShaderExecutor* createExecutor (Context& context, glu::ShaderType shaderType, const ShaderSpec& shaderSpec, VkDescriptorSetLayout extraResourcesLayout) 2870 { 2871 switch (shaderType) 2872 { 2873 case glu::SHADERTYPE_VERTEX: return new VertexShaderExecutor (context, shaderSpec, extraResourcesLayout); 2874 case glu::SHADERTYPE_TESSELLATION_CONTROL: return new TessControlExecutor (context, shaderSpec, extraResourcesLayout); 2875 case glu::SHADERTYPE_TESSELLATION_EVALUATION: return new TessEvaluationExecutor (context, shaderSpec, extraResourcesLayout); 2876 case glu::SHADERTYPE_GEOMETRY: return new GeometryShaderExecutor (context, shaderSpec, extraResourcesLayout); 2877 case glu::SHADERTYPE_FRAGMENT: return new FragmentShaderExecutor (context, shaderSpec, extraResourcesLayout); 2878 case glu::SHADERTYPE_COMPUTE: return new ComputeShaderExecutor (context, shaderSpec, extraResourcesLayout); 2879 default: 2880 TCU_THROW(InternalError, "Unsupported shader type"); 2881 } 2882 } 2883 2884 } // shaderexecutor 2885 } // vkt 2886
