1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2014 The Android Open Source Project 6 * Copyright (c) 2016 The Khronos Group Inc. 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 * 20 *//*! 21 * \file 22 * \brief Tessellation Geometry Interaction - Grid render (limits, scatter) 23 *//*--------------------------------------------------------------------*/ 24 25 #include "vktTessellationGeometryGridRenderTests.hpp" 26 #include "vktTestCaseUtil.hpp" 27 #include "vktTessellationUtil.hpp" 28 29 #include "tcuTestLog.hpp" 30 #include "tcuTextureUtil.hpp" 31 #include "tcuSurface.hpp" 32 #include "tcuRGBA.hpp" 33 34 #include "vkDefs.hpp" 35 #include "vkQueryUtil.hpp" 36 #include "vkBuilderUtil.hpp" 37 #include "vkTypeUtil.hpp" 38 #include "vkImageUtil.hpp" 39 40 #include "deUniquePtr.hpp" 41 42 #include <string> 43 #include <vector> 44 45 namespace vkt 46 { 47 namespace tessellation 48 { 49 50 using namespace vk; 51 52 namespace 53 { 54 55 enum Constants 56 { 57 RENDER_SIZE = 256, 58 }; 59 60 enum FlagBits 61 { 62 FLAG_TESSELLATION_MAX_SPEC = 1u << 0, 63 FLAG_GEOMETRY_MAX_SPEC = 1u << 1, 64 FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC = 1u << 2, 65 66 FLAG_GEOMETRY_SCATTER_INSTANCES = 1u << 3, 67 FLAG_GEOMETRY_SCATTER_PRIMITIVES = 1u << 4, 68 FLAG_GEOMETRY_SEPARATE_PRIMITIVES = 1u << 5, //!< if set, geometry shader outputs separate grid cells and not continuous slices 69 FLAG_GEOMETRY_SCATTER_LAYERS = 1u << 6, 70 }; 71 typedef deUint32 Flags; 72 73 class GridRenderTestCase : public TestCase 74 { 75 public: 76 void initPrograms (vk::SourceCollections& programCollection) const; 77 TestInstance* createInstance (Context& context) const; 78 79 GridRenderTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const Flags flags); 80 81 private: 82 const Flags m_flags; 83 const int m_tessGenLevel; 84 const int m_numGeometryInvocations; 85 const int m_numLayers; 86 int m_numGeometryPrimitivesPerInvocation; 87 }; 88 89 GridRenderTestCase::GridRenderTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const Flags flags) 90 : TestCase (testCtx, name, description) 91 , m_flags (flags) 92 , m_tessGenLevel ((m_flags & FLAG_TESSELLATION_MAX_SPEC) ? 64 : 5) 93 , m_numGeometryInvocations ((m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC) ? 32 : 4) 94 , m_numLayers ((m_flags & FLAG_GEOMETRY_SCATTER_LAYERS) ? 8 : 1) 95 { 96 DE_ASSERT(((flags & (FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SCATTER_LAYERS)) != 0) == ((flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) != 0)); 97 98 testCtx.getLog() 99 << tcu::TestLog::Message 100 << "Testing tessellation and geometry shaders that output a large number of primitives.\n" 101 << getDescription() 102 << tcu::TestLog::EndMessage; 103 104 if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS) 105 m_testCtx.getLog() << tcu::TestLog::Message << "Rendering to 2d texture array, numLayers = " << m_numLayers << tcu::TestLog::EndMessage; 106 107 m_testCtx.getLog() 108 << tcu::TestLog::Message 109 << "Tessellation level: " << m_tessGenLevel << ", mode = quad.\n" 110 << "\tEach input patch produces " << (m_tessGenLevel*m_tessGenLevel) << " (" << (m_tessGenLevel*m_tessGenLevel*2) << " triangles)\n" 111 << tcu::TestLog::EndMessage; 112 113 int geometryOutputComponents = 0; 114 int geometryOutputVertices = 0; 115 int geometryTotalOutputComponents = 0; 116 117 if (m_flags & FLAG_GEOMETRY_MAX_SPEC) 118 { 119 m_testCtx.getLog() << tcu::TestLog::Message << "Using geometry shader minimum maximum output limits." << tcu::TestLog::EndMessage; 120 121 geometryOutputComponents = 64; 122 geometryOutputVertices = 256; 123 geometryTotalOutputComponents = 1024; 124 } 125 else 126 { 127 geometryOutputComponents = 64; 128 geometryOutputVertices = 16; 129 geometryTotalOutputComponents = 1024; 130 } 131 132 if ((m_flags & FLAG_GEOMETRY_MAX_SPEC) || (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC)) 133 { 134 tcu::MessageBuilder msg(&m_testCtx.getLog()); 135 136 msg << "Geometry shader, targeting following limits:\n"; 137 138 if (m_flags & FLAG_GEOMETRY_MAX_SPEC) 139 msg << "\tmaxGeometryOutputComponents = " << geometryOutputComponents << "\n" 140 << "\tmaxGeometryOutputVertices = " << geometryOutputVertices << "\n" 141 << "\tmaxGeometryTotalOutputComponents = " << geometryTotalOutputComponents << "\n"; 142 143 if (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC) 144 msg << "\tmaxGeometryShaderInvocations = " << m_numGeometryInvocations; 145 146 msg << tcu::TestLog::EndMessage; 147 } 148 149 const bool separatePrimitives = (m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) != 0; 150 const int numComponentsPerVertex = 8; // vec4 pos, vec4 color 151 int numVerticesPerInvocation = 0; 152 int geometryVerticesPerPrimitive = 0; 153 int geometryPrimitivesOutPerPrimitive = 0; 154 155 if (separatePrimitives) 156 { 157 const int numComponentLimit = geometryTotalOutputComponents / (4 * numComponentsPerVertex); 158 const int numOutputLimit = geometryOutputVertices / 4; 159 160 m_numGeometryPrimitivesPerInvocation = de::min(numComponentLimit, numOutputLimit); 161 numVerticesPerInvocation = m_numGeometryPrimitivesPerInvocation * 4; 162 } 163 else 164 { 165 // If FLAG_GEOMETRY_SEPARATE_PRIMITIVES is not set, geometry shader fills a rectangle area in slices. 166 // Each slice is a triangle strip and is generated by a single shader invocation. 167 // One slice with 4 segment ends (nodes) and 3 segments: 168 // .__.__.__. 169 // |\ |\ |\ | 170 // |_\|_\|_\| 171 172 const int numSliceNodesComponentLimit = geometryTotalOutputComponents / (2 * numComponentsPerVertex); // each node 2 vertices 173 const int numSliceNodesOutputLimit = geometryOutputVertices / 2; // each node 2 vertices 174 const int numSliceNodes = de::min(numSliceNodesComponentLimit, numSliceNodesOutputLimit); 175 176 numVerticesPerInvocation = numSliceNodes * 2; 177 m_numGeometryPrimitivesPerInvocation = (numSliceNodes - 1) * 2; 178 } 179 180 geometryVerticesPerPrimitive = numVerticesPerInvocation * m_numGeometryInvocations; 181 geometryPrimitivesOutPerPrimitive = m_numGeometryPrimitivesPerInvocation * m_numGeometryInvocations; 182 183 m_testCtx.getLog() 184 << tcu::TestLog::Message 185 << "Geometry shader:\n" 186 << "\tTotal output vertex count per invocation: " << numVerticesPerInvocation << "\n" 187 << "\tTotal output primitive count per invocation: " << m_numGeometryPrimitivesPerInvocation << "\n" 188 << "\tNumber of invocations per primitive: " << m_numGeometryInvocations << "\n" 189 << "\tTotal output vertex count per input primitive: " << geometryVerticesPerPrimitive << "\n" 190 << "\tTotal output primitive count per input primitive: " << geometryPrimitivesOutPerPrimitive << "\n" 191 << tcu::TestLog::EndMessage; 192 193 m_testCtx.getLog() 194 << tcu::TestLog::Message 195 << "Program:\n" 196 << "\tTotal program output vertices count per input patch: " << (m_tessGenLevel*m_tessGenLevel*2 * geometryVerticesPerPrimitive) << "\n" 197 << "\tTotal program output primitive count per input patch: " << (m_tessGenLevel*m_tessGenLevel*2 * geometryPrimitivesOutPerPrimitive) << "\n" 198 << tcu::TestLog::EndMessage; 199 } 200 201 void GridRenderTestCase::initPrograms (SourceCollections& programCollection) const 202 { 203 // Vertex shader 204 { 205 std::ostringstream src; 206 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 207 << "\n" 208 << "void main (void)\n" 209 << "{\n" 210 << " gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n" 211 << "}\n"; 212 213 programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); 214 } 215 216 // Fragment shader 217 { 218 std::ostringstream src; 219 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 220 << "layout(location = 0) flat in highp vec4 v_color;\n" 221 << "layout(location = 0) out mediump vec4 fragColor;\n" 222 << "\n" 223 << "void main (void)\n" 224 << "{\n" 225 << " fragColor = v_color;\n" 226 << "}\n"; 227 228 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); 229 } 230 231 // Tessellation control 232 { 233 std::ostringstream src; 234 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 235 "#extension GL_EXT_tessellation_shader : require\n" 236 "layout(vertices = 1) out;\n" 237 "\n" 238 "void main (void)\n" 239 "{\n" 240 " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" 241 " gl_TessLevelInner[0] = float(" << m_tessGenLevel << ");\n" 242 " gl_TessLevelInner[1] = float(" << m_tessGenLevel << ");\n" 243 " gl_TessLevelOuter[0] = float(" << m_tessGenLevel << ");\n" 244 " gl_TessLevelOuter[1] = float(" << m_tessGenLevel << ");\n" 245 " gl_TessLevelOuter[2] = float(" << m_tessGenLevel << ");\n" 246 " gl_TessLevelOuter[3] = float(" << m_tessGenLevel << ");\n" 247 "}\n"; 248 249 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str()); 250 } 251 252 // Tessellation evaluation 253 { 254 std::ostringstream src; 255 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 256 << "#extension GL_EXT_tessellation_shader : require\n" 257 << "layout(quads) in;\n" 258 << "\n" 259 << "layout(location = 0) out mediump ivec2 v_tessellationGridPosition;\n" 260 << "\n" 261 << "// note: No need to use precise gl_Position since position does not depend on order\n" 262 << "void main (void)\n" 263 << "{\n"; 264 265 if (m_flags & (FLAG_GEOMETRY_SCATTER_INSTANCES | FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SCATTER_LAYERS)) 266 src << " // Cover only a small area in a corner. The area will be expanded in geometry shader to cover whole viewport\n" 267 << " gl_Position = vec4(gl_TessCoord.x * 0.3 - 1.0, gl_TessCoord.y * 0.3 - 1.0, 0.0, 1.0);\n"; 268 else 269 src << " // Fill the whole viewport\n" 270 << " gl_Position = vec4(gl_TessCoord.x * 2.0 - 1.0, gl_TessCoord.y * 2.0 - 1.0, 0.0, 1.0);\n"; 271 272 src << " // Calculate position in tessellation grid\n" 273 << " v_tessellationGridPosition = ivec2(round(gl_TessCoord.xy * float(" << m_tessGenLevel << ")));\n" 274 << "}\n"; 275 276 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str()); 277 } 278 279 // Geometry shader 280 { 281 const int numInvocations = m_numGeometryInvocations; 282 const int numPrimitives = m_numGeometryPrimitivesPerInvocation; 283 284 std::ostringstream src; 285 286 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 287 << "#extension GL_EXT_geometry_shader : require\n" 288 << "layout(triangles, invocations = " << numInvocations << ") in;\n" 289 << "layout(triangle_strip, max_vertices = " << ((m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) ? (4 * numPrimitives) : (numPrimitives + 2)) << ") out;\n" 290 << "\n" 291 << "layout(location = 0) in mediump ivec2 v_tessellationGridPosition[];\n" 292 << "layout(location = 0) flat out highp vec4 v_color;\n" 293 << "\n" 294 << "void main (void)\n" 295 << "{\n" 296 << " const float equalThreshold = 0.001;\n" 297 << " const float gapOffset = 0.0001; // subdivision performed by the geometry shader might produce gaps. Fill potential gaps by enlarging the output slice a little.\n" 298 << "\n" 299 << " // Input triangle is generated from an axis-aligned rectangle by splitting it in half\n" 300 << " // Original rectangle can be found by finding the bounding AABB of the triangle\n" 301 << " vec4 aabb = vec4(min(gl_in[0].gl_Position.x, min(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n" 302 << " min(gl_in[0].gl_Position.y, min(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)),\n" 303 << " max(gl_in[0].gl_Position.x, max(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n" 304 << " max(gl_in[0].gl_Position.y, max(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)));\n" 305 << "\n" 306 << " // Location in tessellation grid\n" 307 << " ivec2 gridPosition = ivec2(min(v_tessellationGridPosition[0], min(v_tessellationGridPosition[1], v_tessellationGridPosition[2])));\n" 308 << "\n" 309 << " // Which triangle of the two that split the grid cell\n" 310 << " int numVerticesOnBottomEdge = 0;\n" 311 << " for (int ndx = 0; ndx < 3; ++ndx)\n" 312 << " if (abs(gl_in[ndx].gl_Position.y - aabb.w) < equalThreshold)\n" 313 << " ++numVerticesOnBottomEdge;\n" 314 << " bool isBottomTriangle = numVerticesOnBottomEdge == 2;\n" 315 << "\n"; 316 317 if (m_flags & FLAG_GEOMETRY_SCATTER_PRIMITIVES) 318 { 319 // scatter primitives 320 src << " // Draw grid cells\n" 321 << " int inputTriangleNdx = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n" 322 << " for (int ndx = 0; ndx < " << numPrimitives << "; ++ndx)\n" 323 << " {\n" 324 << " ivec2 dstGridSize = ivec2(" << m_tessGenLevel << " * " << numPrimitives << ", 2 * " << m_tessGenLevel << " * " << numInvocations << ");\n" 325 << " ivec2 dstGridNdx = ivec2(" << m_tessGenLevel << " * ndx + gridPosition.x, " << m_tessGenLevel << " * inputTriangleNdx + 2 * gridPosition.y + ndx * 127) % dstGridSize;\n" 326 << " vec4 dstArea;\n" 327 << " dstArea.x = float(dstGridNdx.x) / float(dstGridSize.x) * 2.0 - 1.0 - gapOffset;\n" 328 << " dstArea.y = float(dstGridNdx.y) / float(dstGridSize.y) * 2.0 - 1.0 - gapOffset;\n" 329 << " dstArea.z = float(dstGridNdx.x+1) / float(dstGridSize.x) * 2.0 - 1.0 + gapOffset;\n" 330 << " dstArea.w = float(dstGridNdx.y+1) / float(dstGridSize.y) * 2.0 - 1.0 + gapOffset;\n" 331 << "\n" 332 << " vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n" 333 << " vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n" 334 << " vec4 outputColor = (((dstGridNdx.y + dstGridNdx.x) % 2) == 0) ? (green) : (yellow);\n" 335 << "\n" 336 << " gl_Position = vec4(dstArea.x, dstArea.y, 0.0, 1.0);\n" 337 << " v_color = outputColor;\n" 338 << " EmitVertex();\n" 339 << "\n" 340 << " gl_Position = vec4(dstArea.x, dstArea.w, 0.0, 1.0);\n" 341 << " v_color = outputColor;\n" 342 << " EmitVertex();\n" 343 << "\n" 344 << " gl_Position = vec4(dstArea.z, dstArea.y, 0.0, 1.0);\n" 345 << " v_color = outputColor;\n" 346 << " EmitVertex();\n" 347 << "\n" 348 << " gl_Position = vec4(dstArea.z, dstArea.w, 0.0, 1.0);\n" 349 << " v_color = outputColor;\n" 350 << " EmitVertex();\n" 351 << " EndPrimitive();\n" 352 << " }\n"; 353 } 354 else if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS) 355 { 356 // Number of subrectangle instances = num layers 357 DE_ASSERT(m_numLayers == numInvocations * 2); 358 359 src << " // Draw grid cells, send each primitive to a separate layer\n" 360 << " int baseLayer = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n" 361 << " for (int ndx = 0; ndx < " << numPrimitives << "; ++ndx)\n" 362 << " {\n" 363 << " ivec2 dstGridSize = ivec2(" << m_tessGenLevel << " * " << numPrimitives << ", " << m_tessGenLevel << ");\n" 364 << " ivec2 dstGridNdx = ivec2((gridPosition.x * " << numPrimitives << " * 7 + ndx)*13, (gridPosition.y * 127 + ndx) * 19) % dstGridSize;\n" 365 << " vec4 dstArea;\n" 366 << " dstArea.x = float(dstGridNdx.x) / float(dstGridSize.x) * 2.0 - 1.0 - gapOffset;\n" 367 << " dstArea.y = float(dstGridNdx.y) / float(dstGridSize.y) * 2.0 - 1.0 - gapOffset;\n" 368 << " dstArea.z = float(dstGridNdx.x+1) / float(dstGridSize.x) * 2.0 - 1.0 + gapOffset;\n" 369 << " dstArea.w = float(dstGridNdx.y+1) / float(dstGridSize.y) * 2.0 - 1.0 + gapOffset;\n" 370 << "\n" 371 << " vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n" 372 << " vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n" 373 << " vec4 outputColor = (((dstGridNdx.y + dstGridNdx.x) % 2) == 0) ? (green) : (yellow);\n" 374 << "\n" 375 << " gl_Position = vec4(dstArea.x, dstArea.y, 0.0, 1.0);\n" 376 << " v_color = outputColor;\n" 377 << " gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n" 378 << " EmitVertex();\n" 379 << "\n" 380 << " gl_Position = vec4(dstArea.x, dstArea.w, 0.0, 1.0);\n" 381 << " v_color = outputColor;\n" 382 << " gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n" 383 << " EmitVertex();\n" 384 << "\n" 385 << " gl_Position = vec4(dstArea.z, dstArea.y, 0.0, 1.0);\n" 386 << " v_color = outputColor;\n" 387 << " gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n" 388 << " EmitVertex();\n" 389 << "\n" 390 << " gl_Position = vec4(dstArea.z, dstArea.w, 0.0, 1.0);\n" 391 << " v_color = outputColor;\n" 392 << " gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n" 393 << " EmitVertex();\n" 394 << " EndPrimitive();\n" 395 << " }\n"; 396 } 397 else 398 { 399 if (m_flags & FLAG_GEOMETRY_SCATTER_INSTANCES) 400 { 401 src << " // Scatter slices\n" 402 << " int inputTriangleNdx = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n" 403 << " ivec2 srcSliceNdx = ivec2(gridPosition.x, gridPosition.y * " << (numInvocations*2) << " + inputTriangleNdx);\n" 404 << " ivec2 dstSliceNdx = ivec2(7 * srcSliceNdx.x, 127 * srcSliceNdx.y) % ivec2(" << m_tessGenLevel << ", " << m_tessGenLevel << " * " << (numInvocations*2) << ");\n" 405 << "\n" 406 << " // Draw slice to the dstSlice slot\n" 407 << " vec4 outputSliceArea;\n" 408 << " outputSliceArea.x = float(dstSliceNdx.x) / float(" << m_tessGenLevel << ") * 2.0 - 1.0 - gapOffset;\n" 409 << " outputSliceArea.y = float(dstSliceNdx.y) / float(" << (m_tessGenLevel * numInvocations * 2) << ") * 2.0 - 1.0 - gapOffset;\n" 410 << " outputSliceArea.z = float(dstSliceNdx.x+1) / float(" << m_tessGenLevel << ") * 2.0 - 1.0 + gapOffset;\n" 411 << " outputSliceArea.w = float(dstSliceNdx.y+1) / float(" << (m_tessGenLevel * numInvocations * 2) << ") * 2.0 - 1.0 + gapOffset;\n"; 412 } 413 else 414 { 415 src << " // Fill the input area with slices\n" 416 << " // Upper triangle produces slices only to the upper half of the quad and vice-versa\n" 417 << " float triangleOffset = (isBottomTriangle) ? ((aabb.w + aabb.y) / 2.0) : (aabb.y);\n" 418 << " // Each slice is a invocation\n" 419 << " float sliceHeight = (aabb.w - aabb.y) / float(2 * " << numInvocations << ");\n" 420 << " float invocationOffset = float(gl_InvocationID) * sliceHeight;\n" 421 << "\n" 422 << " vec4 outputSliceArea;\n" 423 << " outputSliceArea.x = aabb.x - gapOffset;\n" 424 << " outputSliceArea.y = triangleOffset + invocationOffset - gapOffset;\n" 425 << " outputSliceArea.z = aabb.z + gapOffset;\n" 426 << " outputSliceArea.w = triangleOffset + invocationOffset + sliceHeight + gapOffset;\n"; 427 } 428 429 src << "\n" 430 << " // Draw slice\n" 431 << " for (int ndx = 0; ndx < " << ((numPrimitives+2)/2) << "; ++ndx)\n" 432 << " {\n" 433 << " vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n" 434 << " vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n" 435 << " vec4 outputColor = (((gl_InvocationID + ndx) % 2) == 0) ? (green) : (yellow);\n" 436 << " float xpos = mix(outputSliceArea.x, outputSliceArea.z, float(ndx) / float(" << (numPrimitives/2) << "));\n" 437 << "\n" 438 << " gl_Position = vec4(xpos, outputSliceArea.y, 0.0, 1.0);\n" 439 << " v_color = outputColor;\n" 440 << " EmitVertex();\n" 441 << "\n" 442 << " gl_Position = vec4(xpos, outputSliceArea.w, 0.0, 1.0);\n" 443 << " v_color = outputColor;\n" 444 << " EmitVertex();\n" 445 << " }\n"; 446 } 447 448 src << "}\n"; 449 450 programCollection.glslSources.add("geom") << glu::GeometrySource(src.str()); 451 } 452 } 453 454 class GridRenderTestInstance : public TestInstance 455 { 456 public: 457 struct Params 458 { 459 Flags flags; 460 int numLayers; 461 462 Params (void) : flags(), numLayers() {} 463 }; 464 GridRenderTestInstance (Context& context, const Params& params) : TestInstance(context), m_params(params) {} 465 tcu::TestStatus iterate (void); 466 467 private: 468 Params m_params; 469 }; 470 471 TestInstance* GridRenderTestCase::createInstance (Context& context) const 472 { 473 GridRenderTestInstance::Params params; 474 475 params.flags = m_flags; 476 params.numLayers = m_numLayers; 477 478 return new GridRenderTestInstance(context, params); 479 } 480 481 bool verifyResultLayer (tcu::TestLog& log, const tcu::ConstPixelBufferAccess& image, const int layerNdx) 482 { 483 tcu::Surface errorMask (image.getWidth(), image.getHeight()); 484 bool foundError = false; 485 486 tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 487 488 log << tcu::TestLog::Message << "Verifying output layer " << layerNdx << tcu::TestLog::EndMessage; 489 490 for (int y = 0; y < image.getHeight(); ++y) 491 for (int x = 0; x < image.getWidth(); ++x) 492 { 493 const int threshold = 8; 494 const tcu::RGBA color (image.getPixel(x, y)); 495 496 // Color must be a linear combination of green and yellow 497 if (color.getGreen() < 255 - threshold || color.getBlue() > threshold) 498 { 499 errorMask.setPixel(x, y, tcu::RGBA::red()); 500 foundError = true; 501 } 502 } 503 504 if (!foundError) 505 { 506 log << tcu::TestLog::Message << "Image valid." << tcu::TestLog::EndMessage 507 << tcu::TestLog::ImageSet("ImageVerification", "Image verification") 508 << tcu::TestLog::Image("Result", "Rendered result", image) 509 << tcu::TestLog::EndImageSet; 510 return true; 511 } 512 else 513 { 514 log << tcu::TestLog::Message << "Image verification failed, found invalid pixels." << tcu::TestLog::EndMessage 515 << tcu::TestLog::ImageSet("ImageVerification", "Image verification") 516 << tcu::TestLog::Image("Result", "Rendered result", image) 517 << tcu::TestLog::Image("ErrorMask", "Error mask", errorMask.getAccess()) 518 << tcu::TestLog::EndImageSet; 519 return false; 520 } 521 } 522 523 tcu::TestStatus GridRenderTestInstance::iterate (void) 524 { 525 requireFeatures(m_context.getInstanceInterface(), m_context.getPhysicalDevice(), FEATURE_TESSELLATION_SHADER | FEATURE_GEOMETRY_SHADER); 526 527 m_context.getTestContext().getLog() 528 << tcu::TestLog::Message 529 << "Rendering single point at the origin. Expecting yellow and green colored grid-like image. (High-frequency grid may appear unicolored)." 530 << tcu::TestLog::EndMessage; 531 532 const DeviceInterface& vk = m_context.getDeviceInterface(); 533 const VkDevice device = m_context.getDevice(); 534 const VkQueue queue = m_context.getUniversalQueue(); 535 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex(); 536 Allocator& allocator = m_context.getDefaultAllocator(); 537 538 // Color attachment 539 540 const tcu::IVec2 renderSize = tcu::IVec2(RENDER_SIZE, RENDER_SIZE); 541 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM; 542 const VkImageSubresourceRange colorImageAllLayersRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, m_params.numLayers); 543 const VkImageCreateInfo colorImageCreateInfo = makeImageCreateInfo(renderSize, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, m_params.numLayers); 544 const VkImageViewType colorAttachmentViewType = (m_params.numLayers == 1 ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_2D_ARRAY); 545 const Image colorAttachmentImage (vk, device, allocator, colorImageCreateInfo, MemoryRequirement::Any); 546 547 // Color output buffer: image will be copied here for verification (big enough for all layers). 548 549 const VkDeviceSize colorBufferSizeBytes = renderSize.x()*renderSize.y() * m_params.numLayers * tcu::getPixelSize(mapVkFormat(colorFormat)); 550 const Buffer colorBuffer (vk, device, allocator, makeBufferCreateInfo(colorBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible); 551 552 // Pipeline: no vertex input attributes nor descriptors. 553 554 const Unique<VkImageView> colorAttachmentView(makeImageView (vk, device, *colorAttachmentImage, colorAttachmentViewType, colorFormat, colorImageAllLayersRange)); 555 const Unique<VkRenderPass> renderPass (makeRenderPass (vk, device, colorFormat)); 556 const Unique<VkFramebuffer> framebuffer (makeFramebuffer (vk, device, *renderPass, *colorAttachmentView, renderSize.x(), renderSize.y(), m_params.numLayers)); 557 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayoutWithoutDescriptors(vk, device)); 558 const Unique<VkCommandPool> cmdPool (makeCommandPool (vk, device, queueFamilyIndex)); 559 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer (vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 560 561 const Unique<VkPipeline> pipeline (GraphicsPipelineBuilder() 562 .setRenderSize (renderSize) 563 .setShader (vk, device, VK_SHADER_STAGE_VERTEX_BIT, m_context.getBinaryCollection().get("vert"), DE_NULL) 564 .setShader (vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, m_context.getBinaryCollection().get("frag"), DE_NULL) 565 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, m_context.getBinaryCollection().get("tesc"), DE_NULL) 566 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, m_context.getBinaryCollection().get("tese"), DE_NULL) 567 .setShader (vk, device, VK_SHADER_STAGE_GEOMETRY_BIT, m_context.getBinaryCollection().get("geom"), DE_NULL) 568 .build (vk, device, *pipelineLayout, *renderPass)); 569 570 beginCommandBuffer(vk, *cmdBuffer); 571 572 // Change color attachment image layout 573 { 574 const VkImageMemoryBarrier colorAttachmentLayoutBarrier = makeImageMemoryBarrier( 575 (VkAccessFlags)0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 576 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 577 *colorAttachmentImage, colorImageAllLayersRange); 578 579 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, 580 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentLayoutBarrier); 581 } 582 583 // Begin render pass 584 { 585 const VkRect2D renderArea = { 586 makeOffset2D(0, 0), 587 makeExtent2D(renderSize.x(), renderSize.y()), 588 }; 589 const tcu::Vec4 clearColor(0.0f, 0.0f, 0.0f, 1.0f); 590 591 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor); 592 } 593 594 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); 595 596 vk.cmdDraw(*cmdBuffer, 1u, 1u, 0u, 0u); 597 endRenderPass(vk, *cmdBuffer); 598 599 // Copy render result to a host-visible buffer 600 { 601 const VkImageMemoryBarrier colorAttachmentPreCopyBarrier = makeImageMemoryBarrier( 602 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, 603 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 604 *colorAttachmentImage, colorImageAllLayersRange); 605 606 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 607 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentPreCopyBarrier); 608 } 609 { 610 const VkImageSubresourceLayers subresourceLayers = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, m_params.numLayers); 611 const VkBufferImageCopy copyRegion = makeBufferImageCopy(makeExtent3D(renderSize.x(), renderSize.y(), 1), subresourceLayers); 612 vk.cmdCopyImageToBuffer(*cmdBuffer, *colorAttachmentImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *colorBuffer, 1u, ©Region); 613 } 614 { 615 const VkBufferMemoryBarrier postCopyBarrier = makeBufferMemoryBarrier( 616 VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *colorBuffer, 0ull, colorBufferSizeBytes); 617 618 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 619 0u, DE_NULL, 1u, &postCopyBarrier, 0u, DE_NULL); 620 } 621 622 endCommandBuffer(vk, *cmdBuffer); 623 submitCommandsAndWait(vk, device, queue, *cmdBuffer); 624 625 // Verify results 626 { 627 const Allocation& alloc = colorBuffer.getAllocation(); 628 invalidateMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), colorBufferSizeBytes); 629 630 const tcu::ConstPixelBufferAccess imageAllLayers(mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), m_params.numLayers, alloc.getHostPtr()); 631 632 bool allOk = true; 633 for (int ndx = 0; ndx < m_params.numLayers; ++ndx) 634 allOk = allOk && verifyResultLayer(m_context.getTestContext().getLog(), 635 tcu::getSubregion(imageAllLayers, 0, 0, ndx, renderSize.x(), renderSize.y(), 1), 636 ndx); 637 638 return (allOk ? tcu::TestStatus::pass("OK") : tcu::TestStatus::fail("Image comparison failed")); 639 } 640 } 641 642 struct TestCaseDescription 643 { 644 const char* name; 645 const char* desc; 646 Flags flags; 647 }; 648 649 } // anonymous 650 651 //! Ported from dEQP-GLES31.functional.tessellation_geometry_interaction.render.limits.* 652 //! \note Tests that check implementation defined limits were omitted, because they rely on runtime shader source generation 653 //! (e.g. changing the number of vertices output from geometry shader). CTS currently doesn't support that, 654 //! because some platforms require precompiled shaders. 655 tcu::TestCaseGroup* createGeometryGridRenderLimitsTests (tcu::TestContext& testCtx) 656 { 657 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "limits", "Render with properties near their limits")); 658 659 static const TestCaseDescription cases[] = 660 { 661 { 662 "output_required_max_tessellation", 663 "Minimum maximum tessellation level", 664 FLAG_TESSELLATION_MAX_SPEC 665 }, 666 { 667 "output_required_max_geometry", 668 "Output minimum maximum number of vertices the geometry shader", 669 FLAG_GEOMETRY_MAX_SPEC 670 }, 671 { 672 "output_required_max_invocations", 673 "Minimum maximum number of geometry shader invocations", 674 FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC 675 }, 676 }; 677 678 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ++ndx) 679 group->addChild(new GridRenderTestCase(testCtx, cases[ndx].name, cases[ndx].desc, cases[ndx].flags)); 680 681 return group.release(); 682 } 683 684 //! Ported from dEQP-GLES31.functional.tessellation_geometry_interaction.render.scatter.* 685 tcu::TestCaseGroup* createGeometryGridRenderScatterTests (tcu::TestContext& testCtx) 686 { 687 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "scatter", "Scatter output primitives")); 688 689 static const TestCaseDescription cases[] = 690 { 691 { 692 "geometry_scatter_instances", 693 "Each geometry shader instance outputs its primitives far from other instances of the same execution", 694 FLAG_GEOMETRY_SCATTER_INSTANCES 695 }, 696 { 697 "geometry_scatter_primitives", 698 "Each geometry shader instance outputs its primitives far from other primitives of the same instance", 699 FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SEPARATE_PRIMITIVES 700 }, 701 { 702 "geometry_scatter_layers", 703 "Each geometry shader instance outputs its primitives to multiple layers and far from other primitives of the same instance", 704 FLAG_GEOMETRY_SCATTER_LAYERS | FLAG_GEOMETRY_SEPARATE_PRIMITIVES 705 }, 706 }; 707 708 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ++ndx) 709 group->addChild(new GridRenderTestCase(testCtx, cases[ndx].name, cases[ndx].desc, cases[ndx].flags)); 710 711 return group.release(); 712 } 713 714 } // tessellation 715 } // vkt 716
