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 - Passthrough
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktTessellationGeometryPassthroughTests.hpp"
26 #include "vktTestCaseUtil.hpp"
27 #include "vktTessellationUtil.hpp"
28
29 #include "tcuTestLog.hpp"
30 #include "tcuImageCompare.hpp"
31
32 #include "vkDefs.hpp"
33 #include "vkBarrierUtil.hpp"
34 #include "vkQueryUtil.hpp"
35 #include "vkBuilderUtil.hpp"
36 #include "vkTypeUtil.hpp"
37 #include "vkImageUtil.hpp"
38 #include "vkCmdUtil.hpp"
39 #include "vkObjUtil.hpp"
40
41 #include "deUniquePtr.hpp"
42
43 #include <string>
44 #include <vector>
45
46 namespace vkt
47 {
48 namespace tessellation
49 {
50
51 using namespace vk;
52
53 namespace
54 {
55
addVertexAndFragmentShaders(vk::SourceCollections & programCollection)56 void addVertexAndFragmentShaders (vk::SourceCollections& programCollection)
57 {
58 // Vertex shader
59 {
60 std::ostringstream src;
61 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
62 << "\n"
63 << "layout(location = 0) in highp vec4 a_position;\n"
64 << "layout(location = 0) out highp vec4 v_vertex_color;\n"
65 << "\n"
66 << "void main (void)\n"
67 << "{\n"
68 << " gl_Position = a_position;\n"
69 << " v_vertex_color = vec4(a_position.x * 0.5 + 0.5, a_position.y * 0.5 + 0.5, 1.0, 0.4);\n"
70 << "}\n";
71
72 programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
73 }
74
75 // Fragment shader
76 {
77 std::ostringstream src;
78 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
79 << "\n"
80 << "layout(location = 0) in highp vec4 v_fragment_color;\n"
81 << "layout(location = 0) out mediump vec4 fragColor;\n"
82 << "void main (void)\n"
83 << "{\n"
84 << " fragColor = v_fragment_color;\n"
85 << "}\n";
86
87 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
88 }
89 }
90
91 //! Tessellation evaluation shader used in passthrough geometry shader case.
generateTessellationEvaluationShader(const TessPrimitiveType primitiveType,const std::string & colorOutputName)92 std::string generateTessellationEvaluationShader (const TessPrimitiveType primitiveType, const std::string& colorOutputName)
93 {
94 std::ostringstream src;
95 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
96 << "#extension GL_EXT_tessellation_shader : require\n"
97 << "layout(" << getTessPrimitiveTypeShaderName(primitiveType) << ") in;\n"
98 << "\n"
99 << "layout(location = 0) in highp vec4 v_patch_color[];\n"
100 << "layout(location = 0) out highp vec4 " << colorOutputName << ";\n"
101 << "\n"
102 << "// note: No need to use precise gl_Position since we do not require gapless geometry\n"
103 << "void main (void)\n"
104 << "{\n";
105
106 if (primitiveType == TESSPRIMITIVETYPE_TRIANGLES)
107 src << " vec3 weights = vec3(pow(gl_TessCoord.x, 1.3), pow(gl_TessCoord.y, 1.3), pow(gl_TessCoord.z, 1.3));\n"
108 << " vec3 cweights = gl_TessCoord;\n"
109 << " gl_Position = vec4(weights.x * gl_in[0].gl_Position.xyz + weights.y * gl_in[1].gl_Position.xyz + weights.z * gl_in[2].gl_Position.xyz, 1.0);\n"
110 << " " << colorOutputName << " = cweights.x * v_patch_color[0] + cweights.y * v_patch_color[1] + cweights.z * v_patch_color[2];\n";
111 else if (primitiveType == TESSPRIMITIVETYPE_QUADS || primitiveType == TESSPRIMITIVETYPE_ISOLINES)
112 src << " vec2 normalizedCoord = (gl_TessCoord.xy * 2.0 - vec2(1.0));\n"
113 << " vec2 normalizedWeights = normalizedCoord * (vec2(1.0) - 0.3 * cos(normalizedCoord.yx * 1.57));\n"
114 << " vec2 weights = normalizedWeights * 0.5 + vec2(0.5);\n"
115 << " vec2 cweights = gl_TessCoord.xy;\n"
116 << " gl_Position = mix(mix(gl_in[0].gl_Position, gl_in[1].gl_Position, weights.y), mix(gl_in[2].gl_Position, gl_in[3].gl_Position, weights.y), weights.x);\n"
117 << " " << colorOutputName << " = mix(mix(v_patch_color[0], v_patch_color[1], cweights.y), mix(v_patch_color[2], v_patch_color[3], cweights.y), cweights.x);\n";
118 else
119 DE_ASSERT(false);
120
121 src << "}\n";
122
123 return src.str();
124 }
125
126 class IdentityGeometryShaderTestCase : public TestCase
127 {
128 public:
129 void initPrograms (vk::SourceCollections& programCollection) const;
130 TestInstance* createInstance (Context& context) const;
131
IdentityGeometryShaderTestCase(tcu::TestContext & testCtx,const std::string & name,const std::string & description,const TessPrimitiveType primitiveType)132 IdentityGeometryShaderTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TessPrimitiveType primitiveType)
133 : TestCase (testCtx, name, description)
134 , m_primitiveType (primitiveType)
135 {
136 }
137
138 private:
139 const TessPrimitiveType m_primitiveType;
140 };
141
initPrograms(vk::SourceCollections & programCollection) const142 void IdentityGeometryShaderTestCase::initPrograms (vk::SourceCollections& programCollection) const
143 {
144 addVertexAndFragmentShaders(programCollection);
145
146 // Tessellation control
147 {
148 std::ostringstream src;
149 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
150 << "#extension GL_EXT_tessellation_shader : require\n"
151 << "layout(vertices = 4) out;\n"
152 << "\n"
153 << "layout(set = 0, binding = 0, std430) readonly restrict buffer TessLevels {\n"
154 << " float inner0;\n"
155 << " float inner1;\n"
156 << " float outer0;\n"
157 << " float outer1;\n"
158 << " float outer2;\n"
159 << " float outer3;\n"
160 << "} sb_levels;\n"
161 << "\n"
162 << "layout(location = 0) in highp vec4 v_vertex_color[];\n"
163 << "layout(location = 0) out highp vec4 v_patch_color[];\n"
164 << "\n"
165 << "void main (void)\n"
166 << "{\n"
167 << " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
168 << " v_patch_color[gl_InvocationID] = v_vertex_color[gl_InvocationID];\n"
169 << "\n"
170 << " gl_TessLevelInner[0] = sb_levels.inner0;\n"
171 << " gl_TessLevelInner[1] = sb_levels.inner1;\n"
172 << " gl_TessLevelOuter[0] = sb_levels.outer0;\n"
173 << " gl_TessLevelOuter[1] = sb_levels.outer1;\n"
174 << " gl_TessLevelOuter[2] = sb_levels.outer2;\n"
175 << " gl_TessLevelOuter[3] = sb_levels.outer3;\n"
176 << "}\n";
177
178 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str());
179 }
180
181 // Tessellation evaluation shader
182 {
183 programCollection.glslSources.add("tese_to_frag")
184 << glu::TessellationEvaluationSource(generateTessellationEvaluationShader(m_primitiveType, "v_fragment_color"));
185 programCollection.glslSources.add("tese_to_geom")
186 << glu::TessellationEvaluationSource(generateTessellationEvaluationShader(m_primitiveType, "v_evaluated_color"));
187 }
188
189 // Geometry shader
190 {
191 std::ostringstream src;
192 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
193 << "#extension GL_EXT_geometry_shader : require\n"
194 << "layout(" << getGeometryShaderInputPrimitiveTypeShaderName(m_primitiveType, false) << ") in;\n"
195 << "layout(" << getGeometryShaderOutputPrimitiveTypeShaderName(m_primitiveType, false)
196 << ", max_vertices=" << numVerticesPerPrimitive(m_primitiveType, false) << ") out;\n"
197 << "\n"
198 << "layout(location = 0) in highp vec4 v_evaluated_color[];\n"
199 << "layout(location = 0) out highp vec4 v_fragment_color;\n"
200 << "\n"
201 << "void main (void)\n"
202 << "{\n"
203 << " for (int ndx = 0; ndx < gl_in.length(); ++ndx)\n"
204 << " {\n"
205 << " gl_Position = gl_in[ndx].gl_Position;\n"
206 << " v_fragment_color = v_evaluated_color[ndx];\n"
207 << " EmitVertex();\n"
208 << " }\n"
209 << "}\n";
210
211 programCollection.glslSources.add("geom") << glu::GeometrySource(src.str());
212 }
213 }
214
215 class IdentityTessellationShaderTestCase : public TestCase
216 {
217 public:
218 void initPrograms (vk::SourceCollections& programCollection) const;
219 TestInstance* createInstance (Context& context) const;
220
IdentityTessellationShaderTestCase(tcu::TestContext & testCtx,const std::string & name,const std::string & description,const TessPrimitiveType primitiveType)221 IdentityTessellationShaderTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TessPrimitiveType primitiveType)
222 : TestCase (testCtx, name, description)
223 , m_primitiveType (primitiveType)
224 {
225 }
226
227 private:
228 const TessPrimitiveType m_primitiveType;
229 };
230
231 //! Geometry shader used in passthrough tessellation shader case.
generateGeometryShader(const TessPrimitiveType primitiveType,const std::string & colorSourceName)232 std::string generateGeometryShader (const TessPrimitiveType primitiveType, const std::string& colorSourceName)
233 {
234 const int numEmitVertices = (primitiveType == TESSPRIMITIVETYPE_ISOLINES ? 11 : 8);
235
236 std::ostringstream src;
237 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
238 << "#extension GL_EXT_geometry_shader : require\n"
239 << "layout(" << getGeometryShaderInputPrimitiveTypeShaderName(primitiveType, false) << ") in;\n"
240 << "layout(" << getGeometryShaderOutputPrimitiveTypeShaderName(primitiveType, false)
241 << ", max_vertices=" << numEmitVertices << ") out;\n"
242 << "\n"
243 << "layout(location = 0) in highp vec4 " << colorSourceName << "[];\n"
244 << "layout(location = 0) out highp vec4 v_fragment_color;\n"
245 << "\n"
246 << "void main (void)\n"
247 << "{\n";
248
249 if (primitiveType == TESSPRIMITIVETYPE_TRIANGLES)
250 {
251 src << " vec4 centerPos = (gl_in[0].gl_Position + gl_in[1].gl_Position + gl_in[2].gl_Position) / 3.0f;\n"
252 << "\n"
253 << " for (int ndx = 0; ndx < 4; ++ndx)\n"
254 << " {\n"
255 << " gl_Position = centerPos + (centerPos - gl_in[ndx % 3].gl_Position);\n"
256 << " v_fragment_color = " << colorSourceName << "[ndx % 3];\n"
257 << " EmitVertex();\n"
258 << "\n"
259 << " gl_Position = centerPos + 0.7 * (centerPos - gl_in[ndx % 3].gl_Position);\n"
260 << " v_fragment_color = " << colorSourceName << "[ndx % 3];\n"
261 << " EmitVertex();\n"
262 << " }\n";
263 }
264 else if (primitiveType == TESSPRIMITIVETYPE_ISOLINES)
265 {
266 src << " vec4 mdir = vec4(gl_in[0].gl_Position.y - gl_in[1].gl_Position.y, gl_in[1].gl_Position.x - gl_in[0].gl_Position.x, 0.0, 0.0);\n"
267 << " for (int i = 0; i <= 10; ++i)\n"
268 << " {\n"
269 << " float xweight = cos(float(i) / 10.0 * 6.28) * 0.5 + 0.5;\n"
270 << " float mweight = sin(float(i) / 10.0 * 6.28) * 0.1 + 0.1;\n"
271 << " gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, xweight) + mweight * mdir;\n"
272 << " v_fragment_color = mix(" << colorSourceName << "[0], " << colorSourceName << "[1], xweight);\n"
273 << " EmitVertex();\n"
274 << " }\n";
275 }
276 else
277 DE_ASSERT(false);
278
279 src << "}\n";
280
281 return src.str();
282 }
283
initPrograms(vk::SourceCollections & programCollection) const284 void IdentityTessellationShaderTestCase::initPrograms (vk::SourceCollections& programCollection) const
285 {
286 addVertexAndFragmentShaders(programCollection);
287
288 // Tessellation control
289 {
290 std::ostringstream src;
291 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
292 << "#extension GL_EXT_tessellation_shader : require\n"
293 << "layout(vertices = " << numVerticesPerPrimitive(m_primitiveType, false) << ") out;\n"
294 << "\n"
295 << "layout(location = 0) in highp vec4 v_vertex_color[];\n"
296 << "layout(location = 0) out highp vec4 v_control_color[];\n"
297 << "\n"
298 << "void main (void)\n"
299 << "{\n"
300 << " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
301 << " v_control_color[gl_InvocationID] = v_vertex_color[gl_InvocationID];\n"
302 << "\n"
303 << " gl_TessLevelInner[0] = 1.0;\n"
304 << " gl_TessLevelInner[1] = 1.0;\n"
305 << " gl_TessLevelOuter[0] = 1.0;\n"
306 << " gl_TessLevelOuter[1] = 1.0;\n"
307 << " gl_TessLevelOuter[2] = 1.0;\n"
308 << " gl_TessLevelOuter[3] = 1.0;\n"
309 << "}\n";
310
311 programCollection.glslSources.add("tesc") << glu::TessellationControlSource(src.str());
312 }
313
314 // Tessellation evaluation shader
315 {
316 std::ostringstream src;
317 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n"
318 << "#extension GL_EXT_tessellation_shader : require\n"
319 << "layout(" << getTessPrimitiveTypeShaderName(m_primitiveType) << ") in;\n"
320 << "\n"
321 << "layout(location = 0) in highp vec4 v_control_color[];\n"
322 << "layout(location = 0) out highp vec4 v_evaluated_color;\n"
323 << "\n"
324 << "// note: No need to use precise gl_Position since we do not require gapless geometry\n"
325 << "void main (void)\n"
326 << "{\n";
327
328 if (m_primitiveType == TESSPRIMITIVETYPE_TRIANGLES)
329 src << " gl_Position = gl_TessCoord.x * gl_in[0].gl_Position + gl_TessCoord.y * gl_in[1].gl_Position + gl_TessCoord.z * gl_in[2].gl_Position;\n"
330 << " v_evaluated_color = gl_TessCoord.x * v_control_color[0] + gl_TessCoord.y * v_control_color[1] + gl_TessCoord.z * v_control_color[2];\n";
331 else if (m_primitiveType == TESSPRIMITIVETYPE_ISOLINES)
332 src << " gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);\n"
333 << " v_evaluated_color = mix(v_control_color[0], v_control_color[1], gl_TessCoord.x);\n";
334 else
335 DE_ASSERT(false);
336
337 src << "}\n";
338
339 programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(src.str());
340 }
341
342 // Geometry shader
343 {
344 programCollection.glslSources.add("geom_from_tese") << glu::GeometrySource(
345 generateGeometryShader(m_primitiveType, "v_evaluated_color"));
346 programCollection.glslSources.add("geom_from_vert") << glu::GeometrySource(
347 generateGeometryShader(m_primitiveType, "v_vertex_color"));
348 }
349 }
350
getPixelBufferAccess(const DeviceInterface & vk,const VkDevice device,const Buffer & colorBuffer,const VkFormat colorFormat,const VkDeviceSize colorBufferSizeBytes,const tcu::IVec2 & renderSize)351 inline tcu::ConstPixelBufferAccess getPixelBufferAccess (const DeviceInterface& vk,
352 const VkDevice device,
353 const Buffer& colorBuffer,
354 const VkFormat colorFormat,
355 const VkDeviceSize colorBufferSizeBytes,
356 const tcu::IVec2& renderSize)
357 {
358 const Allocation& alloc = colorBuffer.getAllocation();
359 invalidateMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), colorBufferSizeBytes);
360 return tcu::ConstPixelBufferAccess(mapVkFormat(colorFormat), renderSize.x(), renderSize.y(), 1, alloc.getHostPtr());
361 }
362
363 //! When a test case disables tessellation stage and we need to derive a primitive type.
getPrimitiveTopology(const TessPrimitiveType primitiveType)364 VkPrimitiveTopology getPrimitiveTopology (const TessPrimitiveType primitiveType)
365 {
366 switch (primitiveType)
367 {
368 case TESSPRIMITIVETYPE_TRIANGLES:
369 case TESSPRIMITIVETYPE_QUADS:
370 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
371
372 case TESSPRIMITIVETYPE_ISOLINES:
373 return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
374
375 default:
376 DE_ASSERT(false);
377 return VK_PRIMITIVE_TOPOLOGY_LAST;
378 }
379 }
380
381 enum Constants
382 {
383 PIPELINE_CASES = 2,
384 RENDER_SIZE = 256,
385 };
386
387 class PassthroughTestInstance : public TestInstance
388 {
389 public:
390 struct PipelineDescription
391 {
392 bool useTessellation;
393 bool useGeometry;
394 std::string tessEvalShaderName;
395 std::string geomShaderName;
396 std::string description;
397
PipelineDescriptionvkt::tessellation::__anonbc6104680111::PassthroughTestInstance::PipelineDescription398 PipelineDescription (void) : useTessellation(), useGeometry() {}
399 };
400
401 struct Params
402 {
403 bool useTessLevels;
404 TessLevels tessLevels;
405 TessPrimitiveType primitiveType;
406 int inputPatchVertices;
407 std::vector<tcu::Vec4> vertices;
408 PipelineDescription pipelineCases[PIPELINE_CASES]; //!< Each test case renders with two pipelines and compares results
409 std::string message;
410
Paramsvkt::tessellation::__anonbc6104680111::PassthroughTestInstance::Params411 Params (void) : useTessLevels(), tessLevels(), primitiveType(), inputPatchVertices() {}
412 };
413
PassthroughTestInstance(Context & context,const Params & params)414 PassthroughTestInstance (Context& context, const Params& params) : TestInstance(context), m_params(params) {}
415 tcu::TestStatus iterate (void);
416
417 private:
418 const Params m_params;
419 };
420
iterate(void)421 tcu::TestStatus PassthroughTestInstance::iterate (void)
422 {
423 requireFeatures(m_context.getInstanceInterface(), m_context.getPhysicalDevice(), FEATURE_TESSELLATION_SHADER | FEATURE_GEOMETRY_SHADER);
424 DE_STATIC_ASSERT(PIPELINE_CASES == 2);
425
426 const DeviceInterface& vk = m_context.getDeviceInterface();
427 const VkDevice device = m_context.getDevice();
428 const VkQueue queue = m_context.getUniversalQueue();
429 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
430 Allocator& allocator = m_context.getDefaultAllocator();
431
432 // Tessellation levels
433 const Buffer tessLevelsBuffer (vk, device, allocator, makeBufferCreateInfo(sizeof(TessLevels), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible);
434
435 if (m_params.useTessLevels)
436 {
437 const Allocation& alloc = tessLevelsBuffer.getAllocation();
438 TessLevels* const bufferTessLevels = static_cast<TessLevels*>(alloc.getHostPtr());
439 *bufferTessLevels = m_params.tessLevels;
440 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), sizeof(TessLevels));
441 }
442
443 // Vertex attributes
444
445 const VkDeviceSize vertexDataSizeBytes = sizeInBytes(m_params.vertices);
446 const VkFormat vertexFormat = VK_FORMAT_R32G32B32A32_SFLOAT;
447 const Buffer vertexBuffer (vk, device, allocator, makeBufferCreateInfo(vertexDataSizeBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible);
448
449 {
450 const Allocation& alloc = vertexBuffer.getAllocation();
451 deMemcpy(alloc.getHostPtr(), &m_params.vertices[0], static_cast<std::size_t>(vertexDataSizeBytes));
452 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), vertexDataSizeBytes);
453 }
454
455 // Descriptors - make descriptor for tessellation levels, even if we don't use them, to simplify code
456
457 const Unique<VkDescriptorSetLayout> descriptorSetLayout(DescriptorSetLayoutBuilder()
458 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT)
459 .build(vk, device));
460
461 const Unique<VkDescriptorPool> descriptorPool(DescriptorPoolBuilder()
462 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
463 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
464
465 const Unique<VkDescriptorSet> descriptorSet (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
466 const VkDescriptorBufferInfo tessLevelsBufferInfo = makeDescriptorBufferInfo(*tessLevelsBuffer, 0ull, sizeof(TessLevels));
467
468 DescriptorSetUpdateBuilder()
469 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &tessLevelsBufferInfo)
470 .update(vk, device);
471
472 // Color attachment
473
474 const tcu::IVec2 renderSize = tcu::IVec2(RENDER_SIZE, RENDER_SIZE);
475 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
476 const VkImageSubresourceRange colorImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
477 const Image colorAttachmentImage (vk, device, allocator,
478 makeImageCreateInfo(renderSize, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 1u),
479 MemoryRequirement::Any);
480
481 // Color output buffer: image will be copied here for verification.
482 // We use two buffers, one for each case.
483
484 const VkDeviceSize colorBufferSizeBytes = renderSize.x()*renderSize.y() * tcu::getPixelSize(mapVkFormat(colorFormat));
485 const Buffer colorBuffer1 (vk, device, allocator, makeBufferCreateInfo(colorBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
486 const Buffer colorBuffer2 (vk, device, allocator, makeBufferCreateInfo(colorBufferSizeBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT), MemoryRequirement::HostVisible);
487 const Buffer* const colorBuffer[PIPELINE_CASES] = { &colorBuffer1, &colorBuffer2 };
488
489 // Pipeline
490
491 const Unique<VkImageView> colorAttachmentView(makeImageView(vk, device, *colorAttachmentImage, VK_IMAGE_VIEW_TYPE_2D, colorFormat, colorImageSubresourceRange));
492 const Unique<VkRenderPass> renderPass (makeRenderPass(vk, device, colorFormat));
493 const Unique<VkFramebuffer> framebuffer (makeFramebuffer(vk, device, *renderPass, *colorAttachmentView, renderSize.x(), renderSize.y(), 1u));
494 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
495 const Unique<VkCommandPool> cmdPool (makeCommandPool(vk, device, queueFamilyIndex));
496 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
497
498 // Message explaining the test
499 {
500 tcu::TestLog& log = m_context.getTestContext().getLog();
501 log << tcu::TestLog::Message << m_params.message << tcu::TestLog::EndMessage;
502
503 if (m_params.useTessLevels)
504 log << tcu::TestLog::Message << "Tessellation levels: " << getTessellationLevelsString(m_params.tessLevels, m_params.primitiveType) << tcu::TestLog::EndMessage;
505 }
506
507 for (int pipelineNdx = 0; pipelineNdx < PIPELINE_CASES; ++pipelineNdx)
508 {
509 const PipelineDescription& pipelineDescription = m_params.pipelineCases[pipelineNdx];
510 GraphicsPipelineBuilder pipelineBuilder;
511
512 pipelineBuilder
513 .setPrimitiveTopology (getPrimitiveTopology(m_params.primitiveType))
514 .setRenderSize (renderSize)
515 .setBlend (true)
516 .setVertexInputSingleAttribute(vertexFormat, tcu::getPixelSize(mapVkFormat(vertexFormat)))
517 .setPatchControlPoints (m_params.inputPatchVertices)
518 .setShader (vk, device, VK_SHADER_STAGE_VERTEX_BIT, m_context.getBinaryCollection().get("vert"), DE_NULL)
519 .setShader (vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, m_context.getBinaryCollection().get("frag"), DE_NULL);
520
521 if (pipelineDescription.useTessellation)
522 pipelineBuilder
523 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, m_context.getBinaryCollection().get("tesc"), DE_NULL)
524 .setShader (vk, device, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, m_context.getBinaryCollection().get(pipelineDescription.tessEvalShaderName), DE_NULL);
525
526 if (pipelineDescription.useGeometry)
527 pipelineBuilder
528 .setShader (vk, device, VK_SHADER_STAGE_GEOMETRY_BIT, m_context.getBinaryCollection().get(pipelineDescription.geomShaderName), DE_NULL);
529
530 const Unique<VkPipeline> pipeline (pipelineBuilder.build(vk, device, *pipelineLayout, *renderPass));
531
532 // Draw commands
533
534 beginCommandBuffer(vk, *cmdBuffer);
535
536 // Change color attachment image layout
537 {
538 // State is slightly different on the first iteration.
539 const VkImageLayout currentLayout = (pipelineNdx == 0 ? VK_IMAGE_LAYOUT_UNDEFINED : VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
540 const VkAccessFlags srcFlags = (pipelineNdx == 0 ? (VkAccessFlags)0 : (VkAccessFlags)VK_ACCESS_TRANSFER_READ_BIT);
541
542 const VkImageMemoryBarrier colorAttachmentLayoutBarrier = makeImageMemoryBarrier(
543 srcFlags, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
544 currentLayout, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
545 *colorAttachmentImage, colorImageSubresourceRange);
546
547 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0u,
548 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentLayoutBarrier);
549 }
550
551 // Begin render pass
552 {
553 const VkRect2D renderArea = makeRect2D(renderSize);
554 const tcu::Vec4 clearColor (0.0f, 0.0f, 0.0f, 1.0f);
555
556 beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor);
557 }
558
559 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
560 {
561 const VkDeviceSize vertexBufferOffset = 0ull;
562 vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);
563 }
564
565 if (m_params.useTessLevels)
566 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
567
568 vk.cmdDraw(*cmdBuffer, static_cast<deUint32>(m_params.vertices.size()), 1u, 0u, 0u);
569 endRenderPass(vk, *cmdBuffer);
570
571 // Copy render result to a host-visible buffer
572 copyImageToBuffer(vk, *cmdBuffer, *colorAttachmentImage, colorBuffer[pipelineNdx]->get(), renderSize);
573
574 endCommandBuffer(vk, *cmdBuffer);
575 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
576 }
577
578 // Verify results
579
580 tcu::ConstPixelBufferAccess image0 = getPixelBufferAccess(vk, device, *colorBuffer[0], colorFormat, colorBufferSizeBytes, renderSize);
581 tcu::ConstPixelBufferAccess image1 = getPixelBufferAccess(vk, device, *colorBuffer[1], colorFormat, colorBufferSizeBytes, renderSize);
582
583 const tcu::UVec4 colorThreshold (8, 8, 8, 255);
584 const tcu::IVec3 positionDeviation (1, 1, 0); // 3x3 search kernel
585 const bool ignoreOutOfBounds = true;
586
587 tcu::TestLog& log = m_context.getTestContext().getLog();
588 log << tcu::TestLog::Message
589 << "In image comparison:\n"
590 << " Reference - " << m_params.pipelineCases[0].description << "\n"
591 << " Result - " << m_params.pipelineCases[1].description << "\n"
592 << tcu::TestLog::EndMessage;
593
594 const bool ok = tcu::intThresholdPositionDeviationCompare(
595 log, "ImageCompare", "Image comparison", image0, image1, colorThreshold, positionDeviation, ignoreOutOfBounds, tcu::COMPARE_LOG_RESULT);
596
597 return (ok ? tcu::TestStatus::pass("OK") : tcu::TestStatus::fail("Image comparison failed"));
598 }
599
createInstance(Context & context) const600 TestInstance* IdentityGeometryShaderTestCase::createInstance (Context& context) const
601 {
602 PassthroughTestInstance::Params params;
603
604 const float level = 14.0;
605 params.useTessLevels = true;
606 params.tessLevels.inner[0] = level;
607 params.tessLevels.inner[1] = level;
608 params.tessLevels.outer[0] = level;
609 params.tessLevels.outer[1] = level;
610 params.tessLevels.outer[2] = level;
611 params.tessLevels.outer[3] = level;
612
613 params.primitiveType = m_primitiveType;
614 params.inputPatchVertices = (m_primitiveType == TESSPRIMITIVETYPE_TRIANGLES ? 3 : 4);
615
616 params.vertices.push_back(tcu::Vec4( -0.9f, -0.9f, 0.0f, 1.0f ));
617 params.vertices.push_back(tcu::Vec4( -0.9f, 0.9f, 0.0f, 1.0f ));
618 params.vertices.push_back(tcu::Vec4( 0.9f, -0.9f, 0.0f, 1.0f ));
619 params.vertices.push_back(tcu::Vec4( 0.9f, 0.9f, 0.0f, 1.0f ));
620
621 params.pipelineCases[0].useTessellation = true;
622 params.pipelineCases[0].useGeometry = true;
623 params.pipelineCases[0].tessEvalShaderName = "tese_to_geom";
624 params.pipelineCases[0].geomShaderName = "geom";
625 params.pipelineCases[0].description = "passthrough geometry shader";
626
627 params.pipelineCases[1].useTessellation = true;
628 params.pipelineCases[1].useGeometry = false;
629 params.pipelineCases[1].tessEvalShaderName = "tese_to_frag";
630 params.pipelineCases[1].geomShaderName = "geom";
631 params.pipelineCases[1].description = "no geometry shader in the pipeline";
632
633 params.message = "Testing tessellating shader program output does not change when a passthrough geometry shader is attached.\n"
634 "Rendering two images, first with and second without a geometry shader. Expecting similar results.\n"
635 "Using additive blending to detect overlap.\n";
636
637 return new PassthroughTestInstance(context, params);
638 };
639
createInstance(Context & context) const640 TestInstance* IdentityTessellationShaderTestCase::createInstance (Context& context) const
641 {
642 PassthroughTestInstance::Params params;
643
644 params.useTessLevels = false;
645 params.primitiveType = m_primitiveType;
646 params.inputPatchVertices = (m_primitiveType == TESSPRIMITIVETYPE_TRIANGLES ? 3 : 2);
647
648 params.vertices.push_back( tcu::Vec4( -0.4f, 0.4f, 0.0f, 1.0f ));
649 params.vertices.push_back( tcu::Vec4( 0.0f, -0.5f, 0.0f, 1.0f ));
650 if (params.inputPatchVertices == 3)
651 params.vertices.push_back(tcu::Vec4( 0.4f, 0.4f, 0.0f, 1.0f ));
652
653 params.pipelineCases[0].useTessellation = true;
654 params.pipelineCases[0].useGeometry = true;
655 params.pipelineCases[0].tessEvalShaderName = "tese";
656 params.pipelineCases[0].geomShaderName = "geom_from_tese";
657 params.pipelineCases[0].description = "passthrough tessellation shaders";
658
659 params.pipelineCases[1].useTessellation = false;
660 params.pipelineCases[1].useGeometry = true;
661 params.pipelineCases[1].tessEvalShaderName = "tese";
662 params.pipelineCases[1].geomShaderName = "geom_from_vert";
663 params.pipelineCases[1].description = "no tessellation shaders in the pipeline";
664
665 params.message = "Testing geometry shading shader program output does not change when a passthrough tessellation shader is attached.\n"
666 "Rendering two images, first with and second without a tessellation shader. Expecting similar results.\n"
667 "Using additive blending to detect overlap.\n";
668
669 return new PassthroughTestInstance(context, params);
670 };
671
makeIdentityGeometryShaderCase(tcu::TestContext & testCtx,const TessPrimitiveType primitiveType)672 inline TestCase* makeIdentityGeometryShaderCase (tcu::TestContext& testCtx, const TessPrimitiveType primitiveType)
673 {
674 return new IdentityGeometryShaderTestCase(
675 testCtx,
676 "tessellate_" + de::toString(getTessPrimitiveTypeShaderName(primitiveType)) + "_passthrough_geometry_no_change",
677 "Passthrough geometry shader has no effect",
678 primitiveType);
679 }
680
makeIdentityTessellationShaderCase(tcu::TestContext & testCtx,const TessPrimitiveType primitiveType)681 inline TestCase* makeIdentityTessellationShaderCase (tcu::TestContext& testCtx, const TessPrimitiveType primitiveType)
682 {
683 return new IdentityTessellationShaderTestCase(
684 testCtx,
685 "passthrough_tessellation_geometry_shade_" + de::toString(getTessPrimitiveTypeShaderName(primitiveType)) + "_no_change",
686 "Passthrough tessellation shader has no effect",
687 primitiveType);
688 }
689
690 } // anonymous
691
692
693 //! Ported from dEQP-GLES31.functional.tessellation_geometry_interaction.render.passthrough.*
createGeometryPassthroughTests(tcu::TestContext & testCtx)694 tcu::TestCaseGroup* createGeometryPassthroughTests (tcu::TestContext& testCtx)
695 {
696 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "passthrough", "Render various types with either passthrough geometry or tessellation shader"));
697
698 // Passthrough geometry shader
699 group->addChild(makeIdentityGeometryShaderCase(testCtx, TESSPRIMITIVETYPE_TRIANGLES));
700 group->addChild(makeIdentityGeometryShaderCase(testCtx, TESSPRIMITIVETYPE_QUADS));
701 group->addChild(makeIdentityGeometryShaderCase(testCtx, TESSPRIMITIVETYPE_ISOLINES));
702
703 // Passthrough tessellation shader
704 group->addChild(makeIdentityTessellationShaderCase(testCtx, TESSPRIMITIVETYPE_TRIANGLES));
705 group->addChild(makeIdentityTessellationShaderCase(testCtx, TESSPRIMITIVETYPE_ISOLINES));
706
707 return group.release();
708 }
709
710 } // tessellation
711 } // vkt
712