1 /*-------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2015 Google Inc.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Simple Smoke Tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktApiTests.hpp"
25
26 #include "vktTestCaseUtil.hpp"
27
28 #include "vkDefs.hpp"
29 #include "vkPlatform.hpp"
30 #include "vkStrUtil.hpp"
31 #include "vkRef.hpp"
32 #include "vkRefUtil.hpp"
33 #include "vkQueryUtil.hpp"
34 #include "vkMemUtil.hpp"
35 #include "vkDeviceUtil.hpp"
36 #include "vkPrograms.hpp"
37 #include "vkTypeUtil.hpp"
38 #include "vkImageUtil.hpp"
39 #include "vkCmdUtil.hpp"
40 #include "vkObjUtil.hpp"
41
42 #include "tcuTestLog.hpp"
43 #include "tcuFormatUtil.hpp"
44 #include "tcuTextureUtil.hpp"
45 #include "tcuImageCompare.hpp"
46
47 #include "rrRenderer.hpp"
48
49 #include "deUniquePtr.hpp"
50
51 namespace vkt
52 {
53 namespace api
54 {
55
56 namespace
57 {
58
59 using namespace vk;
60 using std::vector;
61 using tcu::TestLog;
62 using de::UniquePtr;
63
createSamplerTest(Context & context)64 tcu::TestStatus createSamplerTest (Context& context)
65 {
66 const VkDevice vkDevice = context.getDevice();
67 const DeviceInterface& vk = context.getDeviceInterface();
68
69 {
70 const struct VkSamplerCreateInfo samplerInfo =
71 {
72 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // sType
73 DE_NULL, // pNext
74 0u, // flags
75 VK_FILTER_NEAREST, // magFilter
76 VK_FILTER_NEAREST, // minFilter
77 VK_SAMPLER_MIPMAP_MODE_NEAREST, // mipmapMode
78 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeU
79 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeV
80 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeW
81 0.0f, // mipLodBias
82 VK_FALSE, // anisotropyEnable
83 1.0f, // maxAnisotropy
84 DE_FALSE, // compareEnable
85 VK_COMPARE_OP_ALWAYS, // compareOp
86 0.0f, // minLod
87 0.0f, // maxLod
88 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // borderColor
89 VK_FALSE, // unnormalizedCoords
90 };
91
92 Move<VkSampler> tmpSampler = createSampler(vk, vkDevice, &samplerInfo);
93 Move<VkSampler> tmp2Sampler;
94
95 tmp2Sampler = tmpSampler;
96
97 const Unique<VkSampler> sampler (tmp2Sampler);
98 }
99
100 return tcu::TestStatus::pass("Creating sampler succeeded");
101 }
102
createShaderProgs(SourceCollections & dst)103 void createShaderProgs (SourceCollections& dst)
104 {
105 dst.glslSources.add("test") << glu::VertexSource(
106 "#version 310 es\n"
107 "layout(location = 0) in highp vec4 a_position;\n"
108 "void main (void) { gl_Position = a_position; }\n");
109 }
110
createShaderModuleTest(Context & context)111 tcu::TestStatus createShaderModuleTest (Context& context)
112 {
113 const VkDevice vkDevice = context.getDevice();
114 const DeviceInterface& vk = context.getDeviceInterface();
115 const Unique<VkShaderModule> shader (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("test"), 0));
116
117 return tcu::TestStatus::pass("Creating shader module succeeded");
118 }
119
createTriangleAsmProgs(SourceCollections & dst)120 void createTriangleAsmProgs (SourceCollections& dst)
121 {
122 dst.spirvAsmSources.add("vert") <<
123 " OpCapability Shader\n"
124 "%1 = OpExtInstImport \"GLSL.std.450\"\n"
125 " OpMemoryModel Logical GLSL450\n"
126 " OpEntryPoint Vertex %4 \"main\" %10 %12 %16 %17\n"
127 " OpSource ESSL 300\n"
128 " OpName %4 \"main\"\n"
129 " OpName %10 \"gl_Position\"\n"
130 " OpName %12 \"a_position\"\n"
131 " OpName %16 \"gl_VertexIndex\"\n"
132 " OpName %17 \"gl_InstanceIndex\"\n"
133 " OpDecorate %10 BuiltIn Position\n"
134 " OpDecorate %12 Location 0\n"
135 " OpDecorate %16 BuiltIn VertexIndex\n"
136 " OpDecorate %17 BuiltIn InstanceIndex\n"
137 "%2 = OpTypeVoid\n"
138 "%3 = OpTypeFunction %2\n"
139 "%7 = OpTypeFloat 32\n"
140 "%8 = OpTypeVector %7 4\n"
141 "%9 = OpTypePointer Output %8\n"
142 "%10 = OpVariable %9 Output\n"
143 "%11 = OpTypePointer Input %8\n"
144 "%12 = OpVariable %11 Input\n"
145 "%14 = OpTypeInt 32 1\n"
146 "%15 = OpTypePointer Input %14\n"
147 "%16 = OpVariable %15 Input\n"
148 "%17 = OpVariable %15 Input\n"
149 "%4 = OpFunction %2 None %3\n"
150 "%5 = OpLabel\n"
151 "%13 = OpLoad %8 %12\n"
152 " OpStore %10 %13\n"
153 " OpBranch %6\n"
154 "%6 = OpLabel\n"
155 " OpReturn\n"
156 " OpFunctionEnd\n";
157 dst.spirvAsmSources.add("frag") <<
158 " OpCapability Shader\n"
159 "%1 = OpExtInstImport \"GLSL.std.450\"\n"
160 " OpMemoryModel Logical GLSL450\n"
161 " OpEntryPoint Fragment %4 \"main\" %10\n"
162 " OpExecutionMode %4 OriginUpperLeft\n"
163 " OpSource ESSL 300\n"
164 " OpName %4 \"main\"\n"
165 " OpName %10 \"o_color\"\n"
166 " OpDecorate %10 RelaxedPrecision\n"
167 " OpDecorate %10 Location 0\n"
168 "%2 = OpTypeVoid\n"
169 "%3 = OpTypeFunction %2\n"
170 "%7 = OpTypeFloat 32\n"
171 "%8 = OpTypeVector %7 4\n"
172 "%9 = OpTypePointer Output %8\n"
173 "%10 = OpVariable %9 Output\n"
174 "%11 = OpConstant %7 1065353216\n"
175 "%12 = OpConstant %7 0\n"
176 "%13 = OpConstantComposite %8 %11 %12 %11 %11\n"
177 "%4 = OpFunction %2 None %3\n"
178 "%5 = OpLabel\n"
179 " OpStore %10 %13\n"
180 " OpBranch %6\n"
181 "%6 = OpLabel\n"
182 " OpReturn\n"
183 " OpFunctionEnd\n";
184 }
185
createTriangleProgs(SourceCollections & dst)186 void createTriangleProgs (SourceCollections& dst)
187 {
188 dst.glslSources.add("vert") << glu::VertexSource(
189 "#version 310 es\n"
190 "layout(location = 0) in highp vec4 a_position;\n"
191 "void main (void) { gl_Position = a_position; }\n");
192 dst.glslSources.add("frag") << glu::FragmentSource(
193 "#version 310 es\n"
194 "layout(location = 0) out lowp vec4 o_color;\n"
195 "void main (void) { o_color = vec4(1.0, 0.0, 1.0, 1.0); }\n");
196 }
197
createProgsNoOpName(SourceCollections & dst)198 void createProgsNoOpName (SourceCollections& dst)
199 {
200 dst.spirvAsmSources.add("vert") <<
201 "OpCapability Shader\n"
202 "%1 = OpExtInstImport \"GLSL.std.450\"\n"
203 "OpMemoryModel Logical GLSL450\n"
204 "OpEntryPoint Vertex %4 \"main\" %20 %22 %26\n"
205 "OpSource ESSL 310\n"
206 "OpMemberDecorate %18 0 BuiltIn Position\n"
207 "OpMemberDecorate %18 1 BuiltIn PointSize\n"
208 "OpDecorate %18 Block\n"
209 "OpDecorate %22 Location 0\n"
210 "OpDecorate %26 Location 2\n"
211 "%2 = OpTypeVoid\n"
212 "%3 = OpTypeFunction %2\n"
213 "%6 = OpTypeFloat 32\n"
214 "%7 = OpTypeVector %6 4\n"
215 "%8 = OpTypeStruct %7\n"
216 "%9 = OpTypePointer Function %8\n"
217 "%11 = OpTypeInt 32 1\n"
218 "%12 = OpConstant %11 0\n"
219 "%13 = OpConstant %6 1\n"
220 "%14 = OpConstant %6 0\n"
221 "%15 = OpConstantComposite %7 %13 %14 %13 %13\n"
222 "%16 = OpTypePointer Function %7\n"
223 "%18 = OpTypeStruct %7 %6\n"
224 "%19 = OpTypePointer Output %18\n"
225 "%20 = OpVariable %19 Output\n"
226 "%21 = OpTypePointer Input %7\n"
227 "%22 = OpVariable %21 Input\n"
228 "%24 = OpTypePointer Output %7\n"
229 "%26 = OpVariable %24 Output\n"
230 "%4 = OpFunction %2 None %3\n"
231 "%5 = OpLabel\n"
232 "%10 = OpVariable %9 Function\n"
233 "%17 = OpAccessChain %16 %10 %12\n"
234 "OpStore %17 %15\n"
235 "%23 = OpLoad %7 %22\n"
236 "%25 = OpAccessChain %24 %20 %12\n"
237 "OpStore %25 %23\n"
238 "%27 = OpAccessChain %16 %10 %12\n"
239 "%28 = OpLoad %7 %27\n"
240 "OpStore %26 %28\n"
241 "OpReturn\n"
242 "OpFunctionEnd\n";
243 dst.spirvAsmSources.add("frag") <<
244 "OpCapability Shader\n"
245 "%1 = OpExtInstImport \"GLSL.std.450\"\n"
246 "OpMemoryModel Logical GLSL450\n"
247 "OpEntryPoint Fragment %4 \"main\" %9 %11\n"
248 "OpExecutionMode %4 OriginUpperLeft\n"
249 "OpSource ESSL 310\n"
250 "OpDecorate %9 RelaxedPrecision\n"
251 "OpDecorate %9 Location 0\n"
252 "OpDecorate %11 Location 2\n"
253 "%2 = OpTypeVoid\n"
254 "%3 = OpTypeFunction %2\n"
255 "%6 = OpTypeFloat 32\n"
256 "%7 = OpTypeVector %6 4\n"
257 "%8 = OpTypePointer Output %7\n"
258 "%9 = OpVariable %8 Output\n"
259 "%10 = OpTypePointer Input %7\n"
260 "%11 = OpVariable %10 Input\n"
261 "%4 = OpFunction %2 None %3\n"
262 "%5 = OpLabel\n"
263 "%12 = OpLoad %7 %11\n"
264 "OpStore %9 %12\n"
265 "OpReturn\n"
266 "OpFunctionEnd\n";
267 }
268
269 class RefVertexShader : public rr::VertexShader
270 {
271 public:
RefVertexShader(void)272 RefVertexShader (void)
273 : rr::VertexShader(1, 0)
274 {
275 m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
276 }
277
shadeVertices(const rr::VertexAttrib * inputs,rr::VertexPacket * const * packets,const int numPackets) const278 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
279 {
280 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
281 {
282 packets[packetNdx]->position = rr::readVertexAttribFloat(inputs[0],
283 packets[packetNdx]->instanceNdx,
284 packets[packetNdx]->vertexNdx);
285 }
286 }
287 };
288
289 class RefFragmentShader : public rr::FragmentShader
290 {
291 public:
RefFragmentShader(void)292 RefFragmentShader (void)
293 : rr::FragmentShader(0, 1)
294 {
295 m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
296 }
297
shadeFragments(rr::FragmentPacket *,const int numPackets,const rr::FragmentShadingContext & context) const298 void shadeFragments (rr::FragmentPacket*, const int numPackets, const rr::FragmentShadingContext& context) const
299 {
300 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
301 {
302 for (int fragNdx = 0; fragNdx < rr::NUM_FRAGMENTS_PER_PACKET; ++fragNdx)
303 {
304 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f));
305 }
306 }
307 }
308 };
309
renderReferenceTriangle(const tcu::PixelBufferAccess & dst,const tcu::Vec4 (& vertices)[3],const int subpixelBits)310 void renderReferenceTriangle (const tcu::PixelBufferAccess& dst, const tcu::Vec4 (&vertices)[3], const int subpixelBits)
311 {
312 const RefVertexShader vertShader;
313 const RefFragmentShader fragShader;
314 const rr::Program program (&vertShader, &fragShader);
315 const rr::MultisamplePixelBufferAccess colorBuffer = rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(dst);
316 const rr::RenderTarget renderTarget (colorBuffer);
317 const rr::RenderState renderState ((rr::ViewportState(colorBuffer)), subpixelBits, rr::VIEWPORTORIENTATION_UPPER_LEFT);
318 const rr::Renderer renderer;
319 const rr::VertexAttrib vertexAttribs[] =
320 {
321 rr::VertexAttrib(rr::VERTEXATTRIBTYPE_FLOAT, 4, sizeof(tcu::Vec4), 0, vertices[0].getPtr())
322 };
323
324 renderer.draw(rr::DrawCommand(renderState,
325 renderTarget,
326 program,
327 DE_LENGTH_OF_ARRAY(vertexAttribs),
328 &vertexAttribs[0],
329 rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, DE_LENGTH_OF_ARRAY(vertices), 0)));
330 }
331
renderTriangleTest(Context & context)332 tcu::TestStatus renderTriangleTest (Context& context)
333 {
334 const VkDevice vkDevice = context.getDevice();
335 const DeviceInterface& vk = context.getDeviceInterface();
336 const VkQueue queue = context.getUniversalQueue();
337 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
338 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
339 const tcu::IVec2 renderSize (256, 256);
340 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
341 const tcu::Vec4 clearColor (0.125f, 0.25f, 0.75f, 1.0f);
342
343 const tcu::Vec4 vertices[] =
344 {
345 tcu::Vec4(-0.5f, -0.5f, 0.0f, 1.0f),
346 tcu::Vec4(+0.5f, -0.5f, 0.0f, 1.0f),
347 tcu::Vec4( 0.0f, +0.5f, 0.0f, 1.0f)
348 };
349
350 const VkBufferCreateInfo vertexBufferParams =
351 {
352 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
353 DE_NULL, // pNext
354 0u, // flags
355 (VkDeviceSize)sizeof(vertices), // size
356 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // usage
357 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
358 1u, // queueFamilyIndexCount
359 &queueFamilyIndex, // pQueueFamilyIndices
360 };
361 const Unique<VkBuffer> vertexBuffer (createBuffer(vk, vkDevice, &vertexBufferParams));
362 const UniquePtr<Allocation> vertexBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible));
363
364 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
365
366 const VkDeviceSize imageSizeBytes = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
367 const VkBufferCreateInfo readImageBufferParams =
368 {
369 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
370 DE_NULL, // pNext
371 (VkBufferCreateFlags)0u, // flags
372 imageSizeBytes, // size
373 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // usage
374 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
375 1u, // queueFamilyIndexCount
376 &queueFamilyIndex, // pQueueFamilyIndices
377 };
378 const Unique<VkBuffer> readImageBuffer (createBuffer(vk, vkDevice, &readImageBufferParams));
379 const UniquePtr<Allocation> readImageBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible));
380
381 VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
382
383 const VkImageCreateInfo imageParams =
384 {
385 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType
386 DE_NULL, // pNext
387 0u, // flags
388 VK_IMAGE_TYPE_2D, // imageType
389 VK_FORMAT_R8G8B8A8_UNORM, // format
390 { (deUint32)renderSize.x(), (deUint32)renderSize.y(), 1 }, // extent
391 1u, // mipLevels
392 1u, // arraySize
393 VK_SAMPLE_COUNT_1_BIT, // samples
394 VK_IMAGE_TILING_OPTIMAL, // tiling
395 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // usage
396 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
397 1u, // queueFamilyIndexCount
398 &queueFamilyIndex, // pQueueFamilyIndices
399 VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
400 };
401
402 const Unique<VkImage> image (createImage(vk, vkDevice, &imageParams));
403 const UniquePtr<Allocation> imageMemory (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any));
404
405 VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
406
407 const Unique<VkRenderPass> renderPass (makeRenderPass(vk, vkDevice, VK_FORMAT_R8G8B8A8_UNORM));
408
409 const VkImageViewCreateInfo colorAttViewParams =
410 {
411 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // sType
412 DE_NULL, // pNext
413 0u, // flags
414 *image, // image
415 VK_IMAGE_VIEW_TYPE_2D, // viewType
416 VK_FORMAT_R8G8B8A8_UNORM, // format
417 {
418 VK_COMPONENT_SWIZZLE_R,
419 VK_COMPONENT_SWIZZLE_G,
420 VK_COMPONENT_SWIZZLE_B,
421 VK_COMPONENT_SWIZZLE_A
422 }, // components
423 {
424 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
425 0u, // baseMipLevel
426 1u, // levelCount
427 0u, // baseArrayLayer
428 1u, // layerCount
429 }, // subresourceRange
430 };
431 const Unique<VkImageView> colorAttView (createImageView(vk, vkDevice, &colorAttViewParams));
432
433 // Pipeline layout
434 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
435 {
436 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
437 DE_NULL, // pNext
438 (vk::VkPipelineLayoutCreateFlags)0,
439 0u, // setLayoutCount
440 DE_NULL, // pSetLayouts
441 0u, // pushConstantRangeCount
442 DE_NULL, // pPushConstantRanges
443 };
444 const Unique<VkPipelineLayout> pipelineLayout (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
445
446 // Shaders
447 const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
448 const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
449
450 // Pipeline
451 const std::vector<VkViewport> viewports (1, makeViewport(renderSize));
452 const std::vector<VkRect2D> scissors (1, makeRect2D(renderSize));
453
454 const Unique<VkPipeline> pipeline (makeGraphicsPipeline(vk, // const DeviceInterface& vk
455 vkDevice, // const VkDevice device
456 *pipelineLayout, // const VkPipelineLayout pipelineLayout
457 *vertShaderModule, // const VkShaderModule vertexShaderModule
458 DE_NULL, // const VkShaderModule tessellationControlModule
459 DE_NULL, // const VkShaderModule tessellationEvalModule
460 DE_NULL, // const VkShaderModule geometryShaderModule
461 *fragShaderModule, // const VkShaderModule fragmentShaderModule
462 *renderPass, // const VkRenderPass renderPass
463 viewports, // const std::vector<VkViewport>& viewports
464 scissors)); // const std::vector<VkRect2D>& scissors
465
466 // Framebuffer
467 const VkFramebufferCreateInfo framebufferParams =
468 {
469 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // sType
470 DE_NULL, // pNext
471 0u, // flags
472 *renderPass, // renderPass
473 1u, // attachmentCount
474 &*colorAttView, // pAttachments
475 (deUint32)renderSize.x(), // width
476 (deUint32)renderSize.y(), // height
477 1u, // layers
478 };
479 const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
480
481 const VkCommandPoolCreateInfo cmdPoolParams =
482 {
483 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
484 DE_NULL, // pNext
485 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // flags
486 queueFamilyIndex, // queueFamilyIndex
487 };
488 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, vkDevice, &cmdPoolParams));
489
490 // Command buffer
491 const VkCommandBufferAllocateInfo cmdBufParams =
492 {
493 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
494 DE_NULL, // pNext
495 *cmdPool, // pool
496 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
497 1u, // bufferCount
498 };
499 const Unique<VkCommandBuffer> cmdBuf (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
500
501 // Record commands
502 beginCommandBuffer(vk, *cmdBuf);
503
504 {
505 const VkMemoryBarrier vertFlushBarrier =
506 {
507 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // sType
508 DE_NULL, // pNext
509 VK_ACCESS_HOST_WRITE_BIT, // srcAccessMask
510 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, // dstAccessMask
511 };
512 const VkImageMemoryBarrier colorAttBarrier =
513 {
514 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
515 DE_NULL, // pNext
516 0u, // srcAccessMask
517 (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|
518 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT), // dstAccessMask
519 VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
520 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
521 queueFamilyIndex, // srcQueueFamilyIndex
522 queueFamilyIndex, // dstQueueFamilyIndex
523 *image, // image
524 {
525 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
526 0u, // baseMipLevel
527 1u, // levelCount
528 0u, // baseArrayLayer
529 1u, // layerCount
530 } // subresourceRange
531 };
532 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0, 1, &vertFlushBarrier, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &colorAttBarrier);
533 }
534
535 beginRenderPass(vk, *cmdBuf, *renderPass, *framebuffer, makeRect2D(0, 0, renderSize.x(), renderSize.y()), clearColor);
536
537 vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
538 {
539 const VkDeviceSize bindingOffset = 0;
540 vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
541 }
542 vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
543 endRenderPass(vk, *cmdBuf);
544 copyImageToBuffer(vk, *cmdBuf, *image, *readImageBuffer, renderSize);
545 endCommandBuffer(vk, *cmdBuf);
546
547 // Upload vertex data
548 deMemcpy(vertexBufferMemory->getHostPtr(), &vertices[0], sizeof(vertices));
549 flushAlloc(vk, vkDevice, *vertexBufferMemory);
550
551 // Submit & wait for completion
552 submitCommandsAndWait(vk, vkDevice, queue, cmdBuf.get());
553
554 // Read results, render reference, compare
555 {
556 const tcu::TextureFormat tcuFormat = vk::mapVkFormat(colorFormat);
557 const tcu::ConstPixelBufferAccess resultAccess (tcuFormat, renderSize.x(), renderSize.y(), 1, readImageBufferMemory->getHostPtr());
558
559 invalidateAlloc(vk, vkDevice, *readImageBufferMemory);
560
561 {
562 tcu::TextureLevel refImage (tcuFormat, renderSize.x(), renderSize.y());
563 const tcu::UVec4 threshold (0u);
564 const tcu::IVec3 posDeviation (1,1,0);
565
566 tcu::clear(refImage.getAccess(), clearColor);
567 renderReferenceTriangle(refImage.getAccess(), vertices, context.getDeviceProperties().limits.subPixelPrecisionBits);
568
569 if (tcu::intThresholdPositionDeviationCompare(context.getTestContext().getLog(),
570 "ComparisonResult",
571 "Image comparison result",
572 refImage.getAccess(),
573 resultAccess,
574 threshold,
575 posDeviation,
576 false,
577 tcu::COMPARE_LOG_RESULT))
578 return tcu::TestStatus::pass("Rendering succeeded");
579 else
580 return tcu::TestStatus::fail("Image comparison failed");
581 }
582 }
583
584 return tcu::TestStatus::pass("Rendering succeeded");
585 }
586
587 struct VoidVulkanStruct
588 {
589 VkStructureType sType;
590 const void* pNext;
591 };
592
renderTriangleDummyExtStructTest(Context & context)593 tcu::TestStatus renderTriangleDummyExtStructTest (Context& context)
594 {
595 const VkDevice vkDevice = context.getDevice();
596 const DeviceInterface& vk = context.getDeviceInterface();
597 const VkQueue queue = context.getUniversalQueue();
598 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
599 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
600 const tcu::IVec2 renderSize (256, 256);
601 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
602 const tcu::Vec4 clearColor (0.125f, 0.25f, 0.75f, 1.0f);
603
604 // This structure will stand in as an unknown extension structure that must be ignored by implementations.
605 VoidVulkanStruct dummyExtStruct =
606 {
607 VK_STRUCTURE_TYPE_MAX_ENUM, // sType
608 DE_NULL // pNext
609 };
610
611 const tcu::Vec4 vertices[] =
612 {
613 tcu::Vec4(-0.5f, -0.5f, 0.0f, 1.0f),
614 tcu::Vec4(+0.5f, -0.5f, 0.0f, 1.0f),
615 tcu::Vec4( 0.0f, +0.5f, 0.0f, 1.0f)
616 };
617
618 const VkBufferCreateInfo vertexBufferParams =
619 {
620 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
621 &dummyExtStruct, // pNext
622 0u, // flags
623 (VkDeviceSize)sizeof(vertices), // size
624 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // usage
625 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
626 1u, // queueFamilyIndexCount
627 &queueFamilyIndex, // pQueueFamilyIndices
628 };
629 const Unique<VkBuffer> vertexBuffer (createBuffer(vk, vkDevice, &vertexBufferParams));
630 const UniquePtr<Allocation> vertexBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible));
631
632 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
633
634 const VkDeviceSize imageSizeBytes = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
635 const VkBufferCreateInfo readImageBufferParams =
636 {
637 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
638 &dummyExtStruct, // pNext
639 (VkBufferCreateFlags)0u, // flags
640 imageSizeBytes, // size
641 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // usage
642 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
643 1u, // queueFamilyIndexCount
644 &queueFamilyIndex, // pQueueFamilyIndices
645 };
646 const Unique<VkBuffer> readImageBuffer (createBuffer(vk, vkDevice, &readImageBufferParams));
647 const UniquePtr<Allocation> readImageBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible));
648
649 VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
650
651 const VkImageCreateInfo imageParams =
652 {
653 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType
654 &dummyExtStruct, // pNext
655 0u, // flags
656 VK_IMAGE_TYPE_2D, // imageType
657 VK_FORMAT_R8G8B8A8_UNORM, // format
658 { (deUint32)renderSize.x(), (deUint32)renderSize.y(), 1 }, // extent
659 1u, // mipLevels
660 1u, // arraySize
661 VK_SAMPLE_COUNT_1_BIT, // samples
662 VK_IMAGE_TILING_OPTIMAL, // tiling
663 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // usage
664 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
665 1u, // queueFamilyIndexCount
666 &queueFamilyIndex, // pQueueFamilyIndices
667 VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
668 };
669
670 const Unique<VkImage> image (createImage(vk, vkDevice, &imageParams));
671 const UniquePtr<Allocation> imageMemory (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any));
672
673 VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
674
675 // Render pass
676 const VkAttachmentDescription colorAttachmentDescription =
677 {
678 (VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags
679 VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format
680 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples
681 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp
682 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp
683 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp
684 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp
685 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout
686 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout
687 };
688
689 const VkAttachmentReference colorAttachmentRef =
690 {
691 0u, // deUint32 attachment
692 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout
693 };
694
695 const VkSubpassDescription subpassDescription =
696 {
697 (VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags
698 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
699 0u, // deUint32 inputAttachmentCount
700 DE_NULL, // const VkAttachmentReference* pInputAttachments
701 1u, // deUint32 colorAttachmentCount
702 &colorAttachmentRef, // const VkAttachmentReference* pColorAttachments
703 DE_NULL, // const VkAttachmentReference* pResolveAttachments
704 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment
705 0u, // deUint32 preserveAttachmentCount
706 DE_NULL // const deUint32* pPreserveAttachments
707 };
708
709 const VkRenderPassCreateInfo renderPassInfo =
710 {
711 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType
712 &dummyExtStruct, // const void* pNext
713 (VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags
714 1u, // deUint32 attachmentCount
715 &colorAttachmentDescription, // const VkAttachmentDescription* pAttachments
716 1u, // deUint32 subpassCount
717 &subpassDescription, // const VkSubpassDescription* pSubpasses
718 0u, // deUint32 dependencyCount
719 DE_NULL // const VkSubpassDependency* pDependencies
720 };
721
722 const Unique<VkRenderPass> renderPass (createRenderPass(vk, vkDevice, &renderPassInfo, DE_NULL));
723
724 // Color attachment view
725 const VkImageViewCreateInfo colorAttViewParams =
726 {
727 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // sType
728 &dummyExtStruct, // pNext
729 0u, // flags
730 *image, // image
731 VK_IMAGE_VIEW_TYPE_2D, // viewType
732 VK_FORMAT_R8G8B8A8_UNORM, // format
733 {
734 VK_COMPONENT_SWIZZLE_R,
735 VK_COMPONENT_SWIZZLE_G,
736 VK_COMPONENT_SWIZZLE_B,
737 VK_COMPONENT_SWIZZLE_A
738 }, // components
739 {
740 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
741 0u, // baseMipLevel
742 1u, // levelCount
743 0u, // baseArrayLayer
744 1u, // layerCount
745 }, // subresourceRange
746 };
747 const Unique<VkImageView> colorAttView (createImageView(vk, vkDevice, &colorAttViewParams));
748
749 // Pipeline layout
750 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
751 {
752 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
753 &dummyExtStruct, // pNext
754 (vk::VkPipelineLayoutCreateFlags)0,
755 0u, // setLayoutCount
756 DE_NULL, // pSetLayouts
757 0u, // pushConstantRangeCount
758 DE_NULL, // pPushConstantRanges
759 };
760 const Unique<VkPipelineLayout> pipelineLayout (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
761
762 // Shader modules
763 const ProgramBinary vertBin = context.getBinaryCollection().get("vert");
764 const ProgramBinary fragBin = context.getBinaryCollection().get("frag");
765
766 const struct VkShaderModuleCreateInfo vertModuleInfo =
767 {
768 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
769 &dummyExtStruct,
770 0,
771 (deUintptr)vertBin.getSize(),
772 (const deUint32*)vertBin.getBinary(),
773 };
774
775 const struct VkShaderModuleCreateInfo fragModuleInfo =
776 {
777 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
778 &dummyExtStruct,
779 0,
780 (deUintptr)fragBin.getSize(),
781 (const deUint32*)fragBin.getBinary(),
782 };
783
784 const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, vkDevice, &vertModuleInfo));
785 const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, vkDevice, &fragModuleInfo));
786
787 // Pipeline
788 const std::vector<VkViewport> viewports (1, makeViewport(renderSize));
789 const std::vector<VkRect2D> scissors (1, makeRect2D(renderSize));
790
791 VkPipelineShaderStageCreateInfo stageCreateInfo =
792 {
793 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType
794 &dummyExtStruct, // const void* pNext
795 0u, // VkPipelineShaderStageCreateFlags flags
796 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage
797 DE_NULL, // VkShaderModule module
798 "main", // const char* pName
799 DE_NULL // const VkSpecializationInfo* pSpecializationInfo
800 };
801
802 std::vector<VkPipelineShaderStageCreateInfo> pipelineShaderStageParams;
803
804 stageCreateInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
805 stageCreateInfo.module = *vertShaderModule;
806 pipelineShaderStageParams.push_back(stageCreateInfo);
807
808 stageCreateInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
809 stageCreateInfo.module = *fragShaderModule;
810 pipelineShaderStageParams.push_back(stageCreateInfo);
811
812 const VkVertexInputBindingDescription vertexInputBindingDescription =
813 {
814 0u, // deUint32 binding
815 sizeof(tcu::Vec4), // deUint32 stride
816 VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate
817 };
818
819 const VkVertexInputAttributeDescription vertexInputAttributeDescription =
820 {
821 0u, // deUint32 location
822 0u, // deUint32 binding
823 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format
824 0u // deUint32 offset
825 };
826
827 const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
828 {
829 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType
830 &dummyExtStruct, // const void* pNext
831 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags
832 1u, // deUint32 vertexBindingDescriptionCount
833 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions
834 1u, // deUint32 vertexAttributeDescriptionCount
835 &vertexInputAttributeDescription // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions
836 };
837
838 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo =
839 {
840 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType
841 &dummyExtStruct, // const void* pNext
842 0u, // VkPipelineInputAssemblyStateCreateFlags flags
843 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology
844 VK_FALSE // VkBool32 primitiveRestartEnable
845 };
846
847 const VkPipelineViewportStateCreateInfo viewportStateCreateInfo =
848 {
849 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType
850 &dummyExtStruct, // const void* pNext
851 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags
852 (deUint32)viewports.size(), // deUint32 viewportCount
853 viewports.data(), // const VkViewport* pViewports
854 (deUint32)scissors.size(), // deUint32 scissorCount
855 scissors.data() // const VkRect2D* pScissors
856 };
857
858 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
859 {
860 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType
861 &dummyExtStruct, // const void* pNext
862 0u, // VkPipelineRasterizationStateCreateFlags flags
863 VK_FALSE, // VkBool32 depthClampEnable
864 VK_FALSE, // VkBool32 rasterizerDiscardEnable
865 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode
866 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode
867 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace
868 VK_FALSE, // VkBool32 depthBiasEnable
869 0.0f, // float depthBiasConstantFactor
870 0.0f, // float depthBiasClamp
871 0.0f, // float depthBiasSlopeFactor
872 1.0f // float lineWidth
873 };
874
875 const VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo =
876 {
877 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType
878 &dummyExtStruct, // const void* pNext
879 0u, // VkPipelineMultisampleStateCreateFlags flags
880 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples
881 VK_FALSE, // VkBool32 sampleShadingEnable
882 1.0f, // float minSampleShading
883 DE_NULL, // const VkSampleMask* pSampleMask
884 VK_FALSE, // VkBool32 alphaToCoverageEnable
885 VK_FALSE // VkBool32 alphaToOneEnable
886 };
887
888 const VkStencilOpState stencilOpState =
889 {
890 VK_STENCIL_OP_KEEP, // VkStencilOp failOp
891 VK_STENCIL_OP_KEEP, // VkStencilOp passOp
892 VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp
893 VK_COMPARE_OP_NEVER, // VkCompareOp compareOp
894 0, // deUint32 compareMask
895 0, // deUint32 writeMask
896 0 // deUint32 reference
897 };
898
899 const VkPipelineDepthStencilStateCreateInfo depthStencilStateCreateInfo =
900 {
901 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType
902 &dummyExtStruct, // const void* pNext
903 0u, // VkPipelineDepthStencilStateCreateFlags flags
904 VK_FALSE, // VkBool32 depthTestEnable
905 VK_FALSE, // VkBool32 depthWriteEnable
906 VK_COMPARE_OP_LESS_OR_EQUAL, // VkCompareOp depthCompareOp
907 VK_FALSE, // VkBool32 depthBoundsTestEnable
908 VK_FALSE, // VkBool32 stencilTestEnable
909 stencilOpState, // VkStencilOpState front
910 stencilOpState, // VkStencilOpState back
911 0.0f, // float minDepthBounds
912 1.0f, // float maxDepthBounds
913 };
914
915 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
916 {
917 VK_FALSE, // VkBool32 blendEnable
918 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor
919 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor
920 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp
921 VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor
922 VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor
923 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp
924 VK_COLOR_COMPONENT_R_BIT // VkColorComponentFlags colorWriteMask
925 | VK_COLOR_COMPONENT_G_BIT
926 | VK_COLOR_COMPONENT_B_BIT
927 | VK_COLOR_COMPONENT_A_BIT
928 };
929
930 const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo =
931 {
932 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType
933 &dummyExtStruct, // const void* pNext
934 0u, // VkPipelineColorBlendStateCreateFlags flags
935 VK_FALSE, // VkBool32 logicOpEnable
936 VK_LOGIC_OP_CLEAR, // VkLogicOp logicOp
937 1u, // deUint32 attachmentCount
938 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments
939 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4]
940 };
941
942 const VkGraphicsPipelineCreateInfo pipelineCreateInfo =
943 {
944 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType
945 &dummyExtStruct, // const void* pNext
946 0u, // VkPipelineCreateFlags flags
947 (deUint32)pipelineShaderStageParams.size(), // deUint32 stageCount
948 &pipelineShaderStageParams[0], // const VkPipelineShaderStageCreateInfo* pStages
949 &vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState
950 &inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState
951 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState
952 &viewportStateCreateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState
953 &rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState
954 &multisampleStateCreateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState
955 &depthStencilStateCreateInfo, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState
956 &colorBlendStateCreateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState
957 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState
958 *pipelineLayout, // VkPipelineLayout layout
959 *renderPass, // VkRenderPass renderPass
960 0u, // deUint32 subpass
961 DE_NULL, // VkPipeline basePipelineHandle
962 0 // deInt32 basePipelineIndex
963 };
964
965 const Unique<VkPipeline> pipeline (createGraphicsPipeline(vk, vkDevice, DE_NULL, &pipelineCreateInfo));
966
967 // Framebuffer
968 const VkFramebufferCreateInfo framebufferParams =
969 {
970 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // sType
971 &dummyExtStruct, // pNext
972 0u, // flags
973 *renderPass, // renderPass
974 1u, // attachmentCount
975 &*colorAttView, // pAttachments
976 (deUint32)renderSize.x(), // width
977 (deUint32)renderSize.y(), // height
978 1u, // layers
979 };
980 const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
981
982 // Command buffer
983 const VkCommandPoolCreateInfo cmdPoolParams =
984 {
985 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
986 &dummyExtStruct, // pNext
987 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // flags
988 queueFamilyIndex, // queueFamilyIndex
989 };
990 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, vkDevice, &cmdPoolParams));
991
992 const VkCommandBufferAllocateInfo cmdBufParams =
993 {
994 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
995 &dummyExtStruct, // pNext
996 *cmdPool, // pool
997 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
998 1u, // bufferCount
999 };
1000 const Unique<VkCommandBuffer> cmdBuf (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1001
1002 // Record commands
1003 const VkCommandBufferBeginInfo commandBufBeginParams =
1004 {
1005 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1006 &dummyExtStruct, // const void* pNext;
1007 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1008 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1009 };
1010 VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &commandBufBeginParams));
1011
1012 const VkMemoryBarrier vertFlushBarrier =
1013 {
1014 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // sType
1015 &dummyExtStruct, // pNext
1016 VK_ACCESS_HOST_WRITE_BIT, // srcAccessMask
1017 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, // dstAccessMask
1018 };
1019
1020 const VkImageMemoryBarrier colorAttBarrier =
1021 {
1022 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
1023 &dummyExtStruct, // pNext
1024 0u, // srcAccessMask
1025 (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|
1026 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT), // dstAccessMask
1027 VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
1028 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
1029 queueFamilyIndex, // srcQueueFamilyIndex
1030 queueFamilyIndex, // dstQueueFamilyIndex
1031 *image, // image
1032 {
1033 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1034 0u, // baseMipLevel
1035 1u, // levelCount
1036 0u, // baseArrayLayer
1037 1u, // layerCount
1038 } // subresourceRange
1039 };
1040 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0, 1, &vertFlushBarrier, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &colorAttBarrier);
1041
1042 const VkClearValue clearValue = makeClearValueColor(clearColor);
1043 const VkRenderPassBeginInfo renderPassBeginInfo =
1044 {
1045 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
1046 &dummyExtStruct, // const void* pNext;
1047 *renderPass, // VkRenderPass renderPass;
1048 *framebuffer, // VkFramebuffer framebuffer;
1049 makeRect2D(0, 0, renderSize.x(), renderSize.y()), // VkRect2D renderArea;
1050 1u, // deUint32 clearValueCount;
1051 &clearValue, // const VkClearValue* pClearValues;
1052 };
1053
1054 vk.cmdBeginRenderPass(*cmdBuf, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
1055
1056 vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1057
1058 const VkDeviceSize bindingOffset = 0;
1059 vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
1060
1061 vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
1062 endRenderPass(vk, *cmdBuf);
1063
1064 const VkImageMemoryBarrier imageBarrier =
1065 {
1066 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1067 &dummyExtStruct, // const void* pNext;
1068 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask;
1069 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1070 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
1071 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
1072 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1073 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1074 *image, // VkImage image;
1075 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0, 1u) // VkImageSubresourceRange subresourceRange;
1076 };
1077
1078 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
1079 0u, DE_NULL, 0u, DE_NULL, 1u, &imageBarrier);
1080
1081 const VkImageSubresourceLayers subresource =
1082 {
1083 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1084 0u, // deUint32 mipLevel;
1085 0u, // deUint32 baseArrayLayer;
1086 1u // deUint32 layerCount;
1087 };
1088
1089 const VkBufferImageCopy region =
1090 {
1091 0ull, // VkDeviceSize bufferOffset;
1092 0u, // deUint32 bufferRowLength;
1093 0u, // deUint32 bufferImageHeight;
1094 subresource, // VkImageSubresourceLayers imageSubresource;
1095 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
1096 makeExtent3D(renderSize.x(), renderSize.y(), 1u) // VkExtent3D imageExtent;
1097 };
1098
1099 vk.cmdCopyImageToBuffer(*cmdBuf, *image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *readImageBuffer, 1u, ®ion);
1100
1101 const VkBufferMemoryBarrier bufferBarrier =
1102 {
1103 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1104 &dummyExtStruct, // const void* pNext;
1105 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1106 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1107 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1108 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1109 *readImageBuffer, // VkBuffer buffer;
1110 0ull, // VkDeviceSize offset;
1111 VK_WHOLE_SIZE // VkDeviceSize size;
1112 };
1113
1114 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
1115 0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
1116
1117 endCommandBuffer(vk, *cmdBuf);
1118
1119 // Upload vertex data
1120 const VkMappedMemoryRange flushRange =
1121 {
1122 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
1123 &dummyExtStruct,
1124 vertexBufferMemory->getMemory(),
1125 vertexBufferMemory->getOffset(),
1126 VK_WHOLE_SIZE
1127 };
1128 deMemcpy(vertexBufferMemory->getHostPtr(), &vertices[0], sizeof(vertices));
1129 VK_CHECK(vk.flushMappedMemoryRanges(vkDevice, 1u, &flushRange));
1130
1131 // Submit & wait for completion
1132 const VkFenceCreateInfo createInfo =
1133 {
1134 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
1135 &dummyExtStruct,
1136 0u
1137 };
1138
1139 const Unique<VkFence> fence (createFence(vk, vkDevice, &createInfo, DE_NULL));
1140
1141 const VkSubmitInfo submitInfo =
1142 {
1143 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
1144 &dummyExtStruct, // const void* pNext;
1145 0u, // deUint32 waitSemaphoreCount;
1146 DE_NULL, // const VkSemaphore* pWaitSemaphores;
1147 (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
1148 1u, // deUint32 commandBufferCount;
1149 &*cmdBuf, // const VkCommandBuffer* pCommandBuffers;
1150 0u, // deUint32 signalSemaphoreCount;
1151 DE_NULL, // const VkSemaphore* pSignalSemaphores;
1152 };
1153
1154 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1155 VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
1156
1157 // Read results, render reference, compare
1158 {
1159 const tcu::TextureFormat tcuFormat = vk::mapVkFormat(colorFormat);
1160 const tcu::ConstPixelBufferAccess resultAccess (tcuFormat, renderSize.x(), renderSize.y(), 1, readImageBufferMemory->getHostPtr());
1161
1162 invalidateAlloc(vk, vkDevice, *readImageBufferMemory);
1163
1164 {
1165 tcu::TextureLevel refImage (tcuFormat, renderSize.x(), renderSize.y());
1166 const tcu::UVec4 threshold (0u);
1167 const tcu::IVec3 posDeviation (1,1,0);
1168
1169 tcu::clear(refImage.getAccess(), clearColor);
1170 renderReferenceTriangle(refImage.getAccess(), vertices, context.getDeviceProperties().limits.subPixelPrecisionBits);
1171
1172 if (tcu::intThresholdPositionDeviationCompare(context.getTestContext().getLog(),
1173 "ComparisonResult",
1174 "Image comparison result",
1175 refImage.getAccess(),
1176 resultAccess,
1177 threshold,
1178 posDeviation,
1179 false,
1180 tcu::COMPARE_LOG_RESULT))
1181 return tcu::TestStatus::pass("Rendering succeeded");
1182 else
1183 return tcu::TestStatus::fail("Image comparison failed");
1184 }
1185 }
1186
1187 return tcu::TestStatus::pass("Rendering succeeded");
1188 }
1189
renderTriangleUnusedResolveAttachmentTest(Context & context)1190 tcu::TestStatus renderTriangleUnusedResolveAttachmentTest (Context& context)
1191 {
1192 const VkDevice vkDevice = context.getDevice();
1193 const DeviceInterface& vk = context.getDeviceInterface();
1194 const VkQueue queue = context.getUniversalQueue();
1195 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1196 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
1197 const tcu::IVec2 renderSize (256, 256);
1198 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
1199 const tcu::Vec4 clearColor (0.125f, 0.25f, 0.75f, 1.0f);
1200
1201 const tcu::Vec4 vertices[] =
1202 {
1203 tcu::Vec4(-0.5f, -0.5f, 0.0f, 1.0f),
1204 tcu::Vec4(+0.5f, -0.5f, 0.0f, 1.0f),
1205 tcu::Vec4( 0.0f, +0.5f, 0.0f, 1.0f)
1206 };
1207
1208 const VkBufferCreateInfo vertexBufferParams =
1209 {
1210 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
1211 DE_NULL, // pNext
1212 0u, // flags
1213 (VkDeviceSize)sizeof(vertices), // size
1214 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // usage
1215 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
1216 1u, // queueFamilyIndexCount
1217 &queueFamilyIndex, // pQueueFamilyIndices
1218 };
1219 const Unique<VkBuffer> vertexBuffer (createBuffer(vk, vkDevice, &vertexBufferParams));
1220 const UniquePtr<Allocation> vertexBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible));
1221
1222 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
1223
1224 const VkDeviceSize imageSizeBytes = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
1225 const VkBufferCreateInfo readImageBufferParams =
1226 {
1227 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
1228 DE_NULL, // pNext
1229 (VkBufferCreateFlags)0u, // flags
1230 imageSizeBytes, // size
1231 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // usage
1232 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
1233 1u, // queueFamilyIndexCount
1234 &queueFamilyIndex, // pQueueFamilyIndices
1235 };
1236 const Unique<VkBuffer> readImageBuffer (createBuffer(vk, vkDevice, &readImageBufferParams));
1237 const UniquePtr<Allocation> readImageBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible));
1238
1239 VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
1240
1241 const VkImageCreateInfo imageParams =
1242 {
1243 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType
1244 DE_NULL, // pNext
1245 0u, // flags
1246 VK_IMAGE_TYPE_2D, // imageType
1247 VK_FORMAT_R8G8B8A8_UNORM, // format
1248 { (deUint32)renderSize.x(), (deUint32)renderSize.y(), 1 }, // extent
1249 1u, // mipLevels
1250 1u, // arraySize
1251 VK_SAMPLE_COUNT_1_BIT, // samples
1252 VK_IMAGE_TILING_OPTIMAL, // tiling
1253 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // usage
1254 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
1255 1u, // queueFamilyIndexCount
1256 &queueFamilyIndex, // pQueueFamilyIndices
1257 VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
1258 };
1259
1260 const Unique<VkImage> image (createImage(vk, vkDevice, &imageParams));
1261 const UniquePtr<Allocation> imageMemory (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any));
1262
1263 VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
1264
1265 const VkAttachmentDescription colorAttDesc =
1266 {
1267 0u, // flags
1268 VK_FORMAT_R8G8B8A8_UNORM, // format
1269 VK_SAMPLE_COUNT_1_BIT, // samples
1270 VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
1271 VK_ATTACHMENT_STORE_OP_STORE, // storeOp
1272 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
1273 VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilStoreOp
1274 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // initialLayout
1275 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // finalLayout
1276 };
1277 const VkAttachmentReference colorAttRef =
1278 {
1279 0u, // attachment
1280 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // layout
1281 };
1282 const VkAttachmentReference resolveAttRef =
1283 {
1284 VK_ATTACHMENT_UNUSED,
1285 VK_IMAGE_LAYOUT_GENERAL
1286 };
1287 const VkSubpassDescription subpassDesc =
1288 {
1289 (VkSubpassDescriptionFlags)0u, // flags
1290 VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
1291 0u, // inputAttachmentCount
1292 DE_NULL, // pInputAttachments
1293 1u, // colorAttachmentCount
1294 &colorAttRef, // pColorAttachments
1295 &resolveAttRef, // pResolveAttachments
1296 DE_NULL, // depthStencilAttachment
1297 0u, // preserveAttachmentCount
1298 DE_NULL, // pPreserveAttachments
1299 };
1300 const VkRenderPassCreateInfo renderPassParams =
1301 {
1302 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // sType
1303 DE_NULL, // pNext
1304 0u, // flags
1305 1u, // attachmentCount
1306 &colorAttDesc, // pAttachments
1307 1u, // subpassCount
1308 &subpassDesc, // pSubpasses
1309 0u, // dependencyCount
1310 DE_NULL, // pDependencies
1311 };
1312 const Unique<VkRenderPass> renderPass (createRenderPass(vk, vkDevice, &renderPassParams));
1313
1314 const VkImageViewCreateInfo colorAttViewParams =
1315 {
1316 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // sType
1317 DE_NULL, // pNext
1318 0u, // flags
1319 *image, // image
1320 VK_IMAGE_VIEW_TYPE_2D, // viewType
1321 VK_FORMAT_R8G8B8A8_UNORM, // format
1322 {
1323 VK_COMPONENT_SWIZZLE_R,
1324 VK_COMPONENT_SWIZZLE_G,
1325 VK_COMPONENT_SWIZZLE_B,
1326 VK_COMPONENT_SWIZZLE_A
1327 }, // components
1328 {
1329 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1330 0u, // baseMipLevel
1331 1u, // levelCount
1332 0u, // baseArrayLayer
1333 1u, // layerCount
1334 }, // subresourceRange
1335 };
1336 const Unique<VkImageView> colorAttView (createImageView(vk, vkDevice, &colorAttViewParams));
1337
1338 // Pipeline layout
1339 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
1340 {
1341 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
1342 DE_NULL, // pNext
1343 (vk::VkPipelineLayoutCreateFlags)0,
1344 0u, // setLayoutCount
1345 DE_NULL, // pSetLayouts
1346 0u, // pushConstantRangeCount
1347 DE_NULL, // pPushConstantRanges
1348 };
1349 const Unique<VkPipelineLayout> pipelineLayout (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
1350
1351 // Shaders
1352 const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
1353 const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
1354
1355 // Pipeline
1356 const std::vector<VkViewport> viewports (1, makeViewport(renderSize));
1357 const std::vector<VkRect2D> scissors (1, makeRect2D(renderSize));
1358
1359 const Unique<VkPipeline> pipeline (makeGraphicsPipeline(vk, // const DeviceInterface& vk
1360 vkDevice, // const VkDevice device
1361 *pipelineLayout, // const VkPipelineLayout pipelineLayout
1362 *vertShaderModule, // const VkShaderModule vertexShaderModule
1363 DE_NULL, // const VkShaderModule tessellationControlShaderModule
1364 DE_NULL, // const VkShaderModule tessellationEvalShaderModule
1365 DE_NULL, // const VkShaderModule geometryShaderModule
1366 *fragShaderModule, // const VkShaderModule fragmentShaderModule
1367 *renderPass, // const VkRenderPass renderPass
1368 viewports, // const std::vector<VkViewport>& viewports
1369 scissors)); // const std::vector<VkRect2D>& scissors
1370
1371 // Framebuffer
1372 const VkFramebufferCreateInfo framebufferParams =
1373 {
1374 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // sType
1375 DE_NULL, // pNext
1376 0u, // flags
1377 *renderPass, // renderPass
1378 1u, // attachmentCount
1379 &*colorAttView, // pAttachments
1380 (deUint32)renderSize.x(), // width
1381 (deUint32)renderSize.y(), // height
1382 1u, // layers
1383 };
1384 const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
1385
1386 const VkCommandPoolCreateInfo cmdPoolParams =
1387 {
1388 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
1389 DE_NULL, // pNext
1390 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // flags
1391 queueFamilyIndex, // queueFamilyIndex
1392 };
1393 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, vkDevice, &cmdPoolParams));
1394
1395 // Command buffer
1396 const VkCommandBufferAllocateInfo cmdBufParams =
1397 {
1398 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
1399 DE_NULL, // pNext
1400 *cmdPool, // pool
1401 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
1402 1u, // bufferCount
1403 };
1404 const Unique<VkCommandBuffer> cmdBuf (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1405
1406 // Record commands
1407 beginCommandBuffer(vk, *cmdBuf);
1408
1409 {
1410 const VkMemoryBarrier vertFlushBarrier =
1411 {
1412 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // sType
1413 DE_NULL, // pNext
1414 VK_ACCESS_HOST_WRITE_BIT, // srcAccessMask
1415 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, // dstAccessMask
1416 };
1417 const VkImageMemoryBarrier colorAttBarrier =
1418 {
1419 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
1420 DE_NULL, // pNext
1421 0u, // srcAccessMask
1422 (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|
1423 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT), // dstAccessMask
1424 VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
1425 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
1426 queueFamilyIndex, // srcQueueFamilyIndex
1427 queueFamilyIndex, // dstQueueFamilyIndex
1428 *image, // image
1429 {
1430 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1431 0u, // baseMipLevel
1432 1u, // levelCount
1433 0u, // baseArrayLayer
1434 1u, // layerCount
1435 } // subresourceRange
1436 };
1437 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0, 1, &vertFlushBarrier, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &colorAttBarrier);
1438 }
1439
1440 beginRenderPass(vk, *cmdBuf, *renderPass, *framebuffer, makeRect2D(0, 0, renderSize.x(), renderSize.y()), clearColor);
1441
1442 vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1443 {
1444 const VkDeviceSize bindingOffset = 0;
1445 vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
1446 }
1447 vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
1448 endRenderPass(vk, *cmdBuf);
1449 copyImageToBuffer(vk, *cmdBuf, *image, *readImageBuffer, renderSize);
1450 endCommandBuffer(vk, *cmdBuf);
1451
1452 // Upload vertex data
1453 deMemcpy(vertexBufferMemory->getHostPtr(), &vertices[0], sizeof(vertices));
1454 flushAlloc(vk, vkDevice, *vertexBufferMemory);
1455
1456 // Submit & wait for completion
1457 submitCommandsAndWait(vk, vkDevice, queue, cmdBuf.get());
1458
1459 // Read results, render reference, compare
1460 {
1461 const tcu::TextureFormat tcuFormat = vk::mapVkFormat(colorFormat);
1462 const tcu::ConstPixelBufferAccess resultAccess (tcuFormat, renderSize.x(), renderSize.y(), 1, readImageBufferMemory->getHostPtr());
1463
1464 invalidateAlloc(vk, vkDevice, *readImageBufferMemory);
1465
1466 {
1467 tcu::TextureLevel refImage (tcuFormat, renderSize.x(), renderSize.y());
1468 const tcu::UVec4 threshold (0u);
1469 const tcu::IVec3 posDeviation (1,1,0);
1470
1471 tcu::clear(refImage.getAccess(), clearColor);
1472 renderReferenceTriangle(refImage.getAccess(), vertices, context.getDeviceProperties().limits.subPixelPrecisionBits);
1473
1474 if (tcu::intThresholdPositionDeviationCompare(context.getTestContext().getLog(),
1475 "ComparisonResult",
1476 "Image comparison result",
1477 refImage.getAccess(),
1478 resultAccess,
1479 threshold,
1480 posDeviation,
1481 false,
1482 tcu::COMPARE_LOG_RESULT))
1483 return tcu::TestStatus::pass("Rendering succeeded");
1484 else
1485 return tcu::TestStatus::fail("Image comparison failed");
1486 }
1487 }
1488
1489 return tcu::TestStatus::pass("Rendering succeeded");
1490 }
1491
1492 } // anonymous
1493
createSmokeTests(tcu::TestContext & testCtx)1494 tcu::TestCaseGroup* createSmokeTests (tcu::TestContext& testCtx)
1495 {
1496 de::MovePtr<tcu::TestCaseGroup> smokeTests (new tcu::TestCaseGroup(testCtx, "smoke", "Smoke Tests"));
1497
1498 addFunctionCase (smokeTests.get(), "create_sampler", "", createSamplerTest);
1499 addFunctionCaseWithPrograms (smokeTests.get(), "create_shader", "", createShaderProgs, createShaderModuleTest);
1500 addFunctionCaseWithPrograms (smokeTests.get(), "triangle", "", createTriangleProgs, renderTriangleTest);
1501 addFunctionCaseWithPrograms (smokeTests.get(), "triangle_ext_structs", "", createTriangleProgs, renderTriangleDummyExtStructTest);
1502 addFunctionCaseWithPrograms (smokeTests.get(), "asm_triangle", "", createTriangleAsmProgs, renderTriangleTest);
1503 addFunctionCaseWithPrograms (smokeTests.get(), "asm_triangle_no_opname", "", createProgsNoOpName, renderTriangleTest);
1504 addFunctionCaseWithPrograms (smokeTests.get(), "unused_resolve_attachment", "", createTriangleProgs, renderTriangleUnusedResolveAttachmentTest);
1505
1506 return smokeTests.release();
1507 }
1508
1509 } // api
1510 } // vkt
1511