1 /*-------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015 Google Inc.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * \brief Simple Smoke Tests
22 *//*--------------------------------------------------------------------*/
24 #include "vktApiTests.hpp"
26 #include "vktTestCaseUtil.hpp"
29 #include "vkPlatform.hpp"
30 #include "vkStrUtil.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"
40 #include "tcuTestLog.hpp"
41 #include "tcuFormatUtil.hpp"
42 #include "tcuTextureUtil.hpp"
43 #include "tcuImageCompare.hpp"
45 #include "rrRenderer.hpp"
47 #include "deUniquePtr.hpp"
62 tcu::TestStatus createSamplerTest (Context& context)
64 const VkDevice vkDevice = context.getDevice();
65 const DeviceInterface& vk = context.getDeviceInterface();
68 const struct VkSamplerCreateInfo samplerInfo =
70 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // sType
73 VK_FILTER_NEAREST, // magFilter
74 VK_FILTER_NEAREST, // minFilter
75 VK_SAMPLER_MIPMAP_MODE_NEAREST, // mipmapMode
76 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeU
77 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeV
78 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeW
80 VK_FALSE, // anisotropyEnable
81 1.0f, // maxAnisotropy
82 DE_FALSE, // compareEnable
83 VK_COMPARE_OP_ALWAYS, // compareOp
86 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // borderColor
87 VK_FALSE, // unnormalizedCoords
90 Move<VkSampler> tmpSampler = createSampler(vk, vkDevice, &samplerInfo);
91 Move<VkSampler> tmp2Sampler;
93 tmp2Sampler = tmpSampler;
95 const Unique<VkSampler> sampler (tmp2Sampler);
98 return tcu::TestStatus::pass("Creating sampler succeeded");
101 void createShaderProgs (SourceCollections& dst)
103 dst.glslSources.add("test") << glu::VertexSource(
105 "in highp vec4 a_position;\n"
106 "void main (void) { gl_Position = a_position; }\n");
109 tcu::TestStatus createShaderModuleTest (Context& context)
111 const VkDevice vkDevice = context.getDevice();
112 const DeviceInterface& vk = context.getDeviceInterface();
113 const Unique<VkShaderModule> shader (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("test"), 0));
115 return tcu::TestStatus::pass("Creating shader module succeeded");
118 void createTriangleAsmProgs (SourceCollections& dst)
120 dst.spirvAsmSources.add("vert") <<
121 " OpCapability Shader\n"
122 "%1 = OpExtInstImport \"GLSL.std.450\"\n"
123 " OpMemoryModel Logical GLSL450\n"
124 " OpEntryPoint Vertex %4 \"main\" %10 %12 %16 %17\n"
125 " OpSource ESSL 300\n"
126 " OpName %4 \"main\"\n"
127 " OpName %10 \"gl_Position\"\n"
128 " OpName %12 \"a_position\"\n"
129 " OpName %16 \"gl_VertexIndex\"\n"
130 " OpName %17 \"gl_InstanceIndex\"\n"
131 " OpDecorate %10 BuiltIn Position\n"
132 " OpDecorate %12 Location 0\n"
133 " OpDecorate %16 BuiltIn VertexIndex\n"
134 " OpDecorate %17 BuiltIn InstanceIndex\n"
136 "%3 = OpTypeFunction %2\n"
137 "%7 = OpTypeFloat 32\n"
138 "%8 = OpTypeVector %7 4\n"
139 "%9 = OpTypePointer Output %8\n"
140 "%10 = OpVariable %9 Output\n"
141 "%11 = OpTypePointer Input %8\n"
142 "%12 = OpVariable %11 Input\n"
143 "%14 = OpTypeInt 32 1\n"
144 "%15 = OpTypePointer Input %14\n"
145 "%16 = OpVariable %15 Input\n"
146 "%17 = OpVariable %15 Input\n"
147 "%4 = OpFunction %2 None %3\n"
149 "%13 = OpLoad %8 %12\n"
155 dst.spirvAsmSources.add("frag") <<
156 " OpCapability Shader\n"
157 "%1 = OpExtInstImport \"GLSL.std.450\"\n"
158 " OpMemoryModel Logical GLSL450\n"
159 " OpEntryPoint Fragment %4 \"main\" %10\n"
160 " OpExecutionMode %4 OriginLowerLeft\n"
161 " OpSource ESSL 300\n"
162 " OpName %4 \"main\"\n"
163 " OpName %10 \"o_color\"\n"
164 " OpDecorate %10 RelaxedPrecision\n"
165 " OpDecorate %10 Location 0\n"
167 "%3 = OpTypeFunction %2\n"
168 "%7 = OpTypeFloat 32\n"
169 "%8 = OpTypeVector %7 4\n"
170 "%9 = OpTypePointer Output %8\n"
171 "%10 = OpVariable %9 Output\n"
172 "%11 = OpConstant %7 1065353216\n"
173 "%12 = OpConstant %7 0\n"
174 "%13 = OpConstantComposite %8 %11 %12 %11 %11\n"
175 "%4 = OpFunction %2 None %3\n"
184 void createTriangleProgs (SourceCollections& dst)
186 dst.glslSources.add("vert") << glu::VertexSource(
188 "layout(location = 0) in highp vec4 a_position;\n"
189 "void main (void) { gl_Position = a_position; }\n");
190 dst.glslSources.add("frag") << glu::FragmentSource(
192 "layout(location = 0) out lowp vec4 o_color;\n"
193 "void main (void) { o_color = vec4(1.0, 0.0, 1.0, 1.0); }\n");
196 class RefVertexShader : public rr::VertexShader
199 RefVertexShader (void)
200 : rr::VertexShader(1, 0)
202 m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
205 void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
207 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
209 packets[packetNdx]->position = rr::readVertexAttribFloat(inputs[0],
210 packets[packetNdx]->instanceNdx,
211 packets[packetNdx]->vertexNdx);
216 class RefFragmentShader : public rr::FragmentShader
219 RefFragmentShader (void)
220 : rr::FragmentShader(0, 1)
222 m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
225 void shadeFragments (rr::FragmentPacket*, const int numPackets, const rr::FragmentShadingContext& context) const
227 for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
229 for (int fragNdx = 0; fragNdx < rr::NUM_FRAGMENTS_PER_PACKET; ++fragNdx)
231 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f));
237 void renderReferenceTriangle (const tcu::PixelBufferAccess& dst, const tcu::Vec4 (&vertices)[3])
239 const RefVertexShader vertShader;
240 const RefFragmentShader fragShader;
241 const rr::Program program (&vertShader, &fragShader);
242 const rr::MultisamplePixelBufferAccess colorBuffer = rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(dst);
243 const rr::RenderTarget renderTarget (colorBuffer);
244 const rr::RenderState renderState ((rr::ViewportState(colorBuffer)));
245 const rr::Renderer renderer;
246 const rr::VertexAttrib vertexAttribs[] =
248 rr::VertexAttrib(rr::VERTEXATTRIBTYPE_FLOAT, 4, sizeof(tcu::Vec4), 0, vertices[0].getPtr())
251 renderer.draw(rr::DrawCommand(renderState,
254 DE_LENGTH_OF_ARRAY(vertexAttribs),
256 rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, DE_LENGTH_OF_ARRAY(vertices), 0)));
259 tcu::TestStatus renderTriangleTest (Context& context)
261 const VkDevice vkDevice = context.getDevice();
262 const DeviceInterface& vk = context.getDeviceInterface();
263 const VkQueue queue = context.getUniversalQueue();
264 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
265 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
266 const tcu::IVec2 renderSize (256, 256);
267 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
268 const tcu::Vec4 clearColor (0.125f, 0.25f, 0.75f, 1.0f);
270 const tcu::Vec4 vertices[] =
272 tcu::Vec4(-0.5f, -0.5f, 0.0f, 1.0f),
273 tcu::Vec4(+0.5f, -0.5f, 0.0f, 1.0f),
274 tcu::Vec4( 0.0f, +0.5f, 0.0f, 1.0f)
277 const VkBufferCreateInfo vertexBufferParams =
279 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
282 (VkDeviceSize)sizeof(vertices), // size
283 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // usage
284 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
285 1u, // queueFamilyIndexCount
286 &queueFamilyIndex, // pQueueFamilyIndices
288 const Unique<VkBuffer> vertexBuffer (createBuffer(vk, vkDevice, &vertexBufferParams));
289 const UniquePtr<Allocation> vertexBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible));
291 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
293 const VkDeviceSize imageSizeBytes = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
294 const VkBufferCreateInfo readImageBufferParams =
296 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
298 (VkBufferCreateFlags)0u, // flags
299 imageSizeBytes, // size
300 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // usage
301 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
302 1u, // queueFamilyIndexCount
303 &queueFamilyIndex, // pQueueFamilyIndices
305 const Unique<VkBuffer> readImageBuffer (createBuffer(vk, vkDevice, &readImageBufferParams));
306 const UniquePtr<Allocation> readImageBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible));
308 VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
310 const VkImageCreateInfo imageParams =
312 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType
315 VK_IMAGE_TYPE_2D, // imageType
316 VK_FORMAT_R8G8B8A8_UNORM, // format
317 { (deUint32)renderSize.x(), (deUint32)renderSize.y(), 1 }, // extent
320 VK_SAMPLE_COUNT_1_BIT, // samples
321 VK_IMAGE_TILING_OPTIMAL, // tiling
322 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // usage
323 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
324 1u, // queueFamilyIndexCount
325 &queueFamilyIndex, // pQueueFamilyIndices
326 VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
329 const Unique<VkImage> image (createImage(vk, vkDevice, &imageParams));
330 const UniquePtr<Allocation> imageMemory (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any));
332 VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
334 const VkAttachmentDescription colorAttDesc =
337 VK_FORMAT_R8G8B8A8_UNORM, // format
338 VK_SAMPLE_COUNT_1_BIT, // samples
339 VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
340 VK_ATTACHMENT_STORE_OP_STORE, // storeOp
341 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
342 VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilStoreOp
343 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // initialLayout
344 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // finalLayout
346 const VkAttachmentReference colorAttRef =
349 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // layout
351 const VkSubpassDescription subpassDesc =
353 (VkSubpassDescriptionFlags)0u, // flags
354 VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
355 0u, // inputAttachmentCount
356 DE_NULL, // pInputAttachments
357 1u, // colorAttachmentCount
358 &colorAttRef, // pColorAttachments
359 DE_NULL, // pResolveAttachments
360 DE_NULL, // depthStencilAttachment
361 0u, // preserveAttachmentCount
362 DE_NULL, // pPreserveAttachments
364 const VkRenderPassCreateInfo renderPassParams =
366 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // sType
369 1u, // attachmentCount
370 &colorAttDesc, // pAttachments
372 &subpassDesc, // pSubpasses
373 0u, // dependencyCount
374 DE_NULL, // pDependencies
376 const Unique<VkRenderPass> renderPass (createRenderPass(vk, vkDevice, &renderPassParams));
378 const VkImageViewCreateInfo colorAttViewParams =
380 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // sType
384 VK_IMAGE_VIEW_TYPE_2D, // viewType
385 VK_FORMAT_R8G8B8A8_UNORM, // format
387 VK_COMPONENT_SWIZZLE_R,
388 VK_COMPONENT_SWIZZLE_G,
389 VK_COMPONENT_SWIZZLE_B,
390 VK_COMPONENT_SWIZZLE_A
393 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
396 0u, // baseArrayLayer
398 }, // subresourceRange
400 const Unique<VkImageView> colorAttView (createImageView(vk, vkDevice, &colorAttViewParams));
403 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
405 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
407 (vk::VkPipelineLayoutCreateFlags)0,
408 0u, // setLayoutCount
409 DE_NULL, // pSetLayouts
410 0u, // pushConstantRangeCount
411 DE_NULL, // pPushConstantRanges
413 const Unique<VkPipelineLayout> pipelineLayout (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
416 const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
417 const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
420 const VkSpecializationInfo emptyShaderSpecParams =
427 const VkPipelineShaderStageCreateInfo shaderStageParams[] =
430 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // sType
433 VK_SHADER_STAGE_VERTEX_BIT, // stage
434 *vertShaderModule, // module
436 &emptyShaderSpecParams, // pSpecializationInfo
439 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // sType
442 VK_SHADER_STAGE_FRAGMENT_BIT, // stage
443 *fragShaderModule, // module
445 &emptyShaderSpecParams, // pSpecializationInfo
448 const VkPipelineDepthStencilStateCreateInfo depthStencilParams =
450 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // sType
453 DE_FALSE, // depthTestEnable
454 DE_FALSE, // depthWriteEnable
455 VK_COMPARE_OP_ALWAYS, // depthCompareOp
456 DE_FALSE, // depthBoundsTestEnable
457 DE_FALSE, // stencilTestEnable
459 VK_STENCIL_OP_KEEP, // failOp
460 VK_STENCIL_OP_KEEP, // passOp
461 VK_STENCIL_OP_KEEP, // depthFailOp
462 VK_COMPARE_OP_ALWAYS, // compareOp
468 VK_STENCIL_OP_KEEP, // failOp
469 VK_STENCIL_OP_KEEP, // passOp
470 VK_STENCIL_OP_KEEP, // depthFailOp
471 VK_COMPARE_OP_ALWAYS, // compareOp
476 0.0f, // float minDepthBounds;
477 1.0f, // float maxDepthBounds;
479 const VkViewport viewport0 =
483 (float)renderSize.x(), // width
484 (float)renderSize.y(), // height
488 const VkRect2D scissor0 =
495 (deUint32)renderSize.x(), // width
496 (deUint32)renderSize.y(), // height
499 const VkPipelineViewportStateCreateInfo viewportParams =
501 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // sType
505 &viewport0, // pViewports
507 &scissor0 // pScissors
509 const VkSampleMask sampleMask = ~0u;
510 const VkPipelineMultisampleStateCreateInfo multisampleParams =
512 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // sType
515 VK_SAMPLE_COUNT_1_BIT, // rasterizationSamples
516 VK_FALSE, // sampleShadingEnable
517 0.0f, // minSampleShading
518 &sampleMask, // sampleMask
519 VK_FALSE, // alphaToCoverageEnable
520 VK_FALSE, // alphaToOneEnable
522 const VkPipelineRasterizationStateCreateInfo rasterParams =
524 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // sType
527 VK_TRUE, // depthClampEnable
528 VK_FALSE, // rasterizerDiscardEnable
529 VK_POLYGON_MODE_FILL, // polygonMode
530 VK_CULL_MODE_NONE, // cullMode
531 VK_FRONT_FACE_COUNTER_CLOCKWISE, // frontFace
532 VK_FALSE, // depthBiasEnable
533 0.0f, // depthBiasConstantFactor
534 0.0f, // depthBiasClamp
535 0.0f, // depthBiasSlopeFactor
538 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyParams =
540 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // sType
543 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // topology
544 DE_FALSE, // primitiveRestartEnable
546 const VkVertexInputBindingDescription vertexBinding0 =
549 (deUint32)sizeof(tcu::Vec4), // stride
550 VK_VERTEX_INPUT_RATE_VERTEX, // inputRate
552 const VkVertexInputAttributeDescription vertexAttrib0 =
556 VK_FORMAT_R32G32B32A32_SFLOAT, // format
559 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
561 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // sType
564 1u, // vertexBindingDescriptionCount
565 &vertexBinding0, // pVertexBindingDescriptions
566 1u, // vertexAttributeDescriptionCount
567 &vertexAttrib0, // pVertexAttributeDescriptions
569 const VkPipelineColorBlendAttachmentState attBlendParams =
571 VK_FALSE, // blendEnable
572 VK_BLEND_FACTOR_ONE, // srcColorBlendFactor
573 VK_BLEND_FACTOR_ZERO, // dstColorBlendFactor
574 VK_BLEND_OP_ADD, // colorBlendOp
575 VK_BLEND_FACTOR_ONE, // srcAlphaBlendFactor
576 VK_BLEND_FACTOR_ZERO, // dstAlphaBlendFactor
577 VK_BLEND_OP_ADD, // alphaBlendOp
578 (VK_COLOR_COMPONENT_R_BIT|
579 VK_COLOR_COMPONENT_G_BIT|
580 VK_COLOR_COMPONENT_B_BIT|
581 VK_COLOR_COMPONENT_A_BIT), // colorWriteMask
583 const VkPipelineColorBlendStateCreateInfo blendParams =
585 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // sType
588 DE_FALSE, // logicOpEnable
589 VK_LOGIC_OP_COPY, // logicOp
590 1u, // attachmentCount
591 &attBlendParams, // pAttachments
592 { 0.0f, 0.0f, 0.0f, 0.0f }, // blendConstants[4]
594 const VkGraphicsPipelineCreateInfo pipelineParams =
596 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // sType
599 (deUint32)DE_LENGTH_OF_ARRAY(shaderStageParams), // stageCount
600 shaderStageParams, // pStages
601 &vertexInputStateParams, // pVertexInputState
602 &inputAssemblyParams, // pInputAssemblyState
603 DE_NULL, // pTessellationState
604 &viewportParams, // pViewportState
605 &rasterParams, // pRasterizationState
606 &multisampleParams, // pMultisampleState
607 &depthStencilParams, // pDepthStencilState
608 &blendParams, // pColorBlendState
609 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // pDynamicState
610 *pipelineLayout, // layout
611 *renderPass, // renderPass
613 DE_NULL, // basePipelineHandle
614 0u, // basePipelineIndex
617 const Unique<VkPipeline> pipeline (createGraphicsPipeline(vk, vkDevice, DE_NULL, &pipelineParams));
620 const VkFramebufferCreateInfo framebufferParams =
622 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // sType
625 *renderPass, // renderPass
626 1u, // attachmentCount
627 &*colorAttView, // pAttachments
628 (deUint32)renderSize.x(), // width
629 (deUint32)renderSize.y(), // height
632 const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
634 const VkCommandPoolCreateInfo cmdPoolParams =
636 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
638 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // flags
639 queueFamilyIndex, // queueFamilyIndex
641 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, vkDevice, &cmdPoolParams));
644 const VkCommandBufferAllocateInfo cmdBufParams =
646 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
649 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
652 const Unique<VkCommandBuffer> cmdBuf (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
654 const VkCommandBufferBeginInfo cmdBufBeginParams =
656 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
659 (const VkCommandBufferInheritanceInfo*)DE_NULL,
663 VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginParams));
666 const VkMemoryBarrier vertFlushBarrier =
668 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // sType
670 VK_ACCESS_HOST_WRITE_BIT, // srcAccessMask
671 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, // dstAccessMask
673 const VkImageMemoryBarrier colorAttBarrier =
675 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
678 (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|
679 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT), // dstAccessMask
680 VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
681 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
682 queueFamilyIndex, // srcQueueFamilyIndex
683 queueFamilyIndex, // dstQueueFamilyIndex
686 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
689 0u, // baseArrayLayer
691 } // subresourceRange
693 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);
697 const VkClearValue clearValue = makeClearValueColorF32(clearColor[0],
701 const VkRenderPassBeginInfo passBeginParams =
703 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // sType
705 *renderPass, // renderPass
706 *framebuffer, // framebuffer
709 { (deUint32)renderSize.x(), (deUint32)renderSize.y() }
711 1u, // clearValueCount
712 &clearValue, // pClearValues
714 vk.cmdBeginRenderPass(*cmdBuf, &passBeginParams, VK_SUBPASS_CONTENTS_INLINE);
717 vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
719 const VkDeviceSize bindingOffset = 0;
720 vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
722 vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
723 vk.cmdEndRenderPass(*cmdBuf);
726 const VkImageMemoryBarrier renderFinishBarrier =
728 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
730 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // outputMask
731 VK_ACCESS_TRANSFER_READ_BIT, // inputMask
732 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // oldLayout
733 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // newLayout
734 queueFamilyIndex, // srcQueueFamilyIndex
735 queueFamilyIndex, // dstQueueFamilyIndex
738 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
741 0u, // baseArraySlice
743 } // subresourceRange
745 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &renderFinishBarrier);
749 const VkBufferImageCopy copyParams =
751 (VkDeviceSize)0u, // bufferOffset
752 (deUint32)renderSize.x(), // bufferRowLength
753 (deUint32)renderSize.y(), // bufferImageHeight
755 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
757 0u, // baseArrayLayer
759 }, // imageSubresource
760 { 0u, 0u, 0u }, // imageOffset
762 (deUint32)renderSize.x(),
763 (deUint32)renderSize.y(),
767 vk.cmdCopyImageToBuffer(*cmdBuf, *image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *readImageBuffer, 1u, ©Params);
771 const VkBufferMemoryBarrier copyFinishBarrier =
773 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // sType
775 VK_ACCESS_TRANSFER_WRITE_BIT, // srcAccessMask
776 VK_ACCESS_HOST_READ_BIT, // dstAccessMask
777 queueFamilyIndex, // srcQueueFamilyIndex
778 queueFamilyIndex, // dstQueueFamilyIndex
779 *readImageBuffer, // buffer
781 imageSizeBytes // size
783 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©FinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
786 VK_CHECK(vk.endCommandBuffer(*cmdBuf));
788 // Upload vertex data
790 const VkMappedMemoryRange range =
792 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, // sType
794 vertexBufferMemory->getMemory(), // memory
796 (VkDeviceSize)sizeof(vertices), // size
798 void* vertexBufPtr = vertexBufferMemory->getHostPtr();
800 deMemcpy(vertexBufPtr, &vertices[0], sizeof(vertices));
801 VK_CHECK(vk.flushMappedMemoryRanges(vkDevice, 1u, &range));
804 // Submit & wait for completion
806 const VkFenceCreateInfo fenceParams =
808 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // sType
812 const VkSubmitInfo submitInfo =
814 VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
816 0u, // waitSemaphoreCount
817 DE_NULL, // pWaitSemaphores
818 (const VkPipelineStageFlags*)DE_NULL,
819 1u, // commandBufferCount
820 &cmdBuf.get(), // pCommandBuffers
821 0u, // signalSemaphoreCount
822 DE_NULL, // pSignalSemaphores
824 const Unique<VkFence> fence (createFence(vk, vkDevice, &fenceParams));
826 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
827 VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
830 // Read results, render reference, compare
832 const tcu::TextureFormat tcuFormat = vk::mapVkFormat(colorFormat);
833 const VkMappedMemoryRange range =
835 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, // sType
837 readImageBufferMemory->getMemory(), // memory
839 imageSizeBytes, // size
841 const tcu::ConstPixelBufferAccess resultAccess (tcuFormat, renderSize.x(), renderSize.y(), 1, readImageBufferMemory->getHostPtr());
843 VK_CHECK(vk.invalidateMappedMemoryRanges(vkDevice, 1u, &range));
846 tcu::TextureLevel refImage (tcuFormat, renderSize.x(), renderSize.y());
847 const tcu::UVec4 threshold (0u);
848 const tcu::IVec3 posDeviation (1,1,0);
850 tcu::clear(refImage.getAccess(), clearColor);
851 renderReferenceTriangle(refImage.getAccess(), vertices);
853 if (tcu::intThresholdPositionDeviationCompare(context.getTestContext().getLog(),
855 "Image comparison result",
856 refImage.getAccess(),
861 tcu::COMPARE_LOG_RESULT))
862 return tcu::TestStatus::pass("Rendering succeeded");
864 return tcu::TestStatus::fail("Image comparison failed");
868 return tcu::TestStatus::pass("Rendering succeeded");
871 tcu::TestStatus renderTriangleUnusedResolveAttachmentTest (Context& context)
873 const VkDevice vkDevice = context.getDevice();
874 const DeviceInterface& vk = context.getDeviceInterface();
875 const VkQueue queue = context.getUniversalQueue();
876 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
877 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
878 const tcu::IVec2 renderSize (256, 256);
879 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM;
880 const tcu::Vec4 clearColor (0.125f, 0.25f, 0.75f, 1.0f);
882 const tcu::Vec4 vertices[] =
884 tcu::Vec4(-0.5f, -0.5f, 0.0f, 1.0f),
885 tcu::Vec4(+0.5f, -0.5f, 0.0f, 1.0f),
886 tcu::Vec4( 0.0f, +0.5f, 0.0f, 1.0f)
889 const VkBufferCreateInfo vertexBufferParams =
891 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
894 (VkDeviceSize)sizeof(vertices), // size
895 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // usage
896 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
897 1u, // queueFamilyIndexCount
898 &queueFamilyIndex, // pQueueFamilyIndices
900 const Unique<VkBuffer> vertexBuffer (createBuffer(vk, vkDevice, &vertexBufferParams));
901 const UniquePtr<Allocation> vertexBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible));
903 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
905 const VkDeviceSize imageSizeBytes = (VkDeviceSize)(sizeof(deUint32)*renderSize.x()*renderSize.y());
906 const VkBufferCreateInfo readImageBufferParams =
908 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
910 (VkBufferCreateFlags)0u, // flags
911 imageSizeBytes, // size
912 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // usage
913 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
914 1u, // queueFamilyIndexCount
915 &queueFamilyIndex, // pQueueFamilyIndices
917 const Unique<VkBuffer> readImageBuffer (createBuffer(vk, vkDevice, &readImageBufferParams));
918 const UniquePtr<Allocation> readImageBufferMemory (memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *readImageBuffer), MemoryRequirement::HostVisible));
920 VK_CHECK(vk.bindBufferMemory(vkDevice, *readImageBuffer, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset()));
922 const VkImageCreateInfo imageParams =
924 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // sType
927 VK_IMAGE_TYPE_2D, // imageType
928 VK_FORMAT_R8G8B8A8_UNORM, // format
929 { (deUint32)renderSize.x(), (deUint32)renderSize.y(), 1 }, // extent
932 VK_SAMPLE_COUNT_1_BIT, // samples
933 VK_IMAGE_TILING_OPTIMAL, // tiling
934 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // usage
935 VK_SHARING_MODE_EXCLUSIVE, // sharingMode
936 1u, // queueFamilyIndexCount
937 &queueFamilyIndex, // pQueueFamilyIndices
938 VK_IMAGE_LAYOUT_UNDEFINED, // initialLayout
941 const Unique<VkImage> image (createImage(vk, vkDevice, &imageParams));
942 const UniquePtr<Allocation> imageMemory (memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any));
944 VK_CHECK(vk.bindImageMemory(vkDevice, *image, imageMemory->getMemory(), imageMemory->getOffset()));
946 const VkAttachmentDescription colorAttDesc =
949 VK_FORMAT_R8G8B8A8_UNORM, // format
950 VK_SAMPLE_COUNT_1_BIT, // samples
951 VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
952 VK_ATTACHMENT_STORE_OP_STORE, // storeOp
953 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
954 VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilStoreOp
955 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // initialLayout
956 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // finalLayout
958 const VkAttachmentReference colorAttRef =
961 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // layout
963 const VkAttachmentReference resolveAttRef =
965 VK_ATTACHMENT_UNUSED,
966 VK_IMAGE_LAYOUT_GENERAL
968 const VkSubpassDescription subpassDesc =
970 (VkSubpassDescriptionFlags)0u, // flags
971 VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
972 0u, // inputAttachmentCount
973 DE_NULL, // pInputAttachments
974 1u, // colorAttachmentCount
975 &colorAttRef, // pColorAttachments
976 &resolveAttRef, // pResolveAttachments
977 DE_NULL, // depthStencilAttachment
978 0u, // preserveAttachmentCount
979 DE_NULL, // pPreserveAttachments
981 const VkRenderPassCreateInfo renderPassParams =
983 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // sType
986 1u, // attachmentCount
987 &colorAttDesc, // pAttachments
989 &subpassDesc, // pSubpasses
990 0u, // dependencyCount
991 DE_NULL, // pDependencies
993 const Unique<VkRenderPass> renderPass (createRenderPass(vk, vkDevice, &renderPassParams));
995 const VkImageViewCreateInfo colorAttViewParams =
997 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // sType
1001 VK_IMAGE_VIEW_TYPE_2D, // viewType
1002 VK_FORMAT_R8G8B8A8_UNORM, // format
1004 VK_COMPONENT_SWIZZLE_R,
1005 VK_COMPONENT_SWIZZLE_G,
1006 VK_COMPONENT_SWIZZLE_B,
1007 VK_COMPONENT_SWIZZLE_A
1010 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1013 0u, // baseArrayLayer
1015 }, // subresourceRange
1017 const Unique<VkImageView> colorAttView (createImageView(vk, vkDevice, &colorAttViewParams));
1020 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
1022 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
1024 (vk::VkPipelineLayoutCreateFlags)0,
1025 0u, // setLayoutCount
1026 DE_NULL, // pSetLayouts
1027 0u, // pushConstantRangeCount
1028 DE_NULL, // pPushConstantRanges
1030 const Unique<VkPipelineLayout> pipelineLayout (createPipelineLayout(vk, vkDevice, &pipelineLayoutParams));
1033 const Unique<VkShaderModule> vertShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("vert"), 0));
1034 const Unique<VkShaderModule> fragShaderModule (createShaderModule(vk, vkDevice, context.getBinaryCollection().get("frag"), 0));
1037 const VkSpecializationInfo emptyShaderSpecParams =
1039 0u, // mapEntryCount
1044 const VkPipelineShaderStageCreateInfo shaderStageParams[] =
1047 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // sType
1050 VK_SHADER_STAGE_VERTEX_BIT, // stage
1051 *vertShaderModule, // module
1053 &emptyShaderSpecParams, // pSpecializationInfo
1056 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // sType
1059 VK_SHADER_STAGE_FRAGMENT_BIT, // stage
1060 *fragShaderModule, // module
1062 &emptyShaderSpecParams, // pSpecializationInfo
1065 const VkPipelineDepthStencilStateCreateInfo depthStencilParams =
1067 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // sType
1070 DE_FALSE, // depthTestEnable
1071 DE_FALSE, // depthWriteEnable
1072 VK_COMPARE_OP_ALWAYS, // depthCompareOp
1073 DE_FALSE, // depthBoundsTestEnable
1074 DE_FALSE, // stencilTestEnable
1076 VK_STENCIL_OP_KEEP, // failOp
1077 VK_STENCIL_OP_KEEP, // passOp
1078 VK_STENCIL_OP_KEEP, // depthFailOp
1079 VK_COMPARE_OP_ALWAYS, // compareOp
1085 VK_STENCIL_OP_KEEP, // failOp
1086 VK_STENCIL_OP_KEEP, // passOp
1087 VK_STENCIL_OP_KEEP, // depthFailOp
1088 VK_COMPARE_OP_ALWAYS, // compareOp
1093 -1.0f, // float minDepthBounds;
1094 +1.0f, // float maxDepthBounds;
1096 const VkViewport viewport0 =
1100 (float)renderSize.x(), // width
1101 (float)renderSize.y(), // height
1105 const VkRect2D scissor0 =
1112 (deUint32)renderSize.x(), // width
1113 (deUint32)renderSize.y(), // height
1116 const VkPipelineViewportStateCreateInfo viewportParams =
1118 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // sType
1121 1u, // viewportCount
1122 &viewport0, // pViewports
1124 &scissor0 // pScissors
1126 const VkSampleMask sampleMask = ~0u;
1127 const VkPipelineMultisampleStateCreateInfo multisampleParams =
1129 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // sType
1132 VK_SAMPLE_COUNT_1_BIT, // rasterizationSamples
1133 VK_FALSE, // sampleShadingEnable
1134 0.0f, // minSampleShading
1135 &sampleMask, // sampleMask
1136 VK_FALSE, // alphaToCoverageEnable
1137 VK_FALSE, // alphaToOneEnable
1139 const VkPipelineRasterizationStateCreateInfo rasterParams =
1141 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // sType
1144 VK_TRUE, // depthClampEnable
1145 VK_FALSE, // rasterizerDiscardEnable
1146 VK_POLYGON_MODE_FILL, // polygonMode
1147 VK_CULL_MODE_NONE, // cullMode
1148 VK_FRONT_FACE_COUNTER_CLOCKWISE, // frontFace
1149 VK_FALSE, // depthBiasEnable
1150 0.0f, // depthBiasConstantFactor
1151 0.0f, // depthBiasClamp
1152 0.0f, // depthBiasSlopeFactor
1155 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyParams =
1157 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // sType
1160 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // topology
1161 DE_FALSE, // primitiveRestartEnable
1163 const VkVertexInputBindingDescription vertexBinding0 =
1166 (deUint32)sizeof(tcu::Vec4), // stride
1167 VK_VERTEX_INPUT_RATE_VERTEX, // inputRate
1169 const VkVertexInputAttributeDescription vertexAttrib0 =
1173 VK_FORMAT_R32G32B32A32_SFLOAT, // format
1176 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
1178 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // sType
1181 1u, // vertexBindingDescriptionCount
1182 &vertexBinding0, // pVertexBindingDescriptions
1183 1u, // vertexAttributeDescriptionCount
1184 &vertexAttrib0, // pVertexAttributeDescriptions
1186 const VkPipelineColorBlendAttachmentState attBlendParams =
1188 VK_FALSE, // blendEnable
1189 VK_BLEND_FACTOR_ONE, // srcColorBlendFactor
1190 VK_BLEND_FACTOR_ZERO, // dstColorBlendFactor
1191 VK_BLEND_OP_ADD, // colorBlendOp
1192 VK_BLEND_FACTOR_ONE, // srcAlphaBlendFactor
1193 VK_BLEND_FACTOR_ZERO, // dstAlphaBlendFactor
1194 VK_BLEND_OP_ADD, // alphaBlendOp
1195 (VK_COLOR_COMPONENT_R_BIT|
1196 VK_COLOR_COMPONENT_G_BIT|
1197 VK_COLOR_COMPONENT_B_BIT|
1198 VK_COLOR_COMPONENT_A_BIT), // colorWriteMask
1200 const VkPipelineColorBlendStateCreateInfo blendParams =
1202 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // sType
1205 DE_FALSE, // logicOpEnable
1206 VK_LOGIC_OP_COPY, // logicOp
1207 1u, // attachmentCount
1208 &attBlendParams, // pAttachments
1209 { 0.0f, 0.0f, 0.0f, 0.0f }, // blendConstants[4]
1211 const VkGraphicsPipelineCreateInfo pipelineParams =
1213 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // sType
1216 (deUint32)DE_LENGTH_OF_ARRAY(shaderStageParams), // stageCount
1217 shaderStageParams, // pStages
1218 &vertexInputStateParams, // pVertexInputState
1219 &inputAssemblyParams, // pInputAssemblyState
1220 DE_NULL, // pTessellationState
1221 &viewportParams, // pViewportState
1222 &rasterParams, // pRasterizationState
1223 &multisampleParams, // pMultisampleState
1224 &depthStencilParams, // pDepthStencilState
1225 &blendParams, // pColorBlendState
1226 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // pDynamicState
1227 *pipelineLayout, // layout
1228 *renderPass, // renderPass
1230 DE_NULL, // basePipelineHandle
1231 0u, // basePipelineIndex
1234 const Unique<VkPipeline> pipeline (createGraphicsPipeline(vk, vkDevice, DE_NULL, &pipelineParams));
1237 const VkFramebufferCreateInfo framebufferParams =
1239 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // sType
1242 *renderPass, // renderPass
1243 1u, // attachmentCount
1244 &*colorAttView, // pAttachments
1245 (deUint32)renderSize.x(), // width
1246 (deUint32)renderSize.y(), // height
1249 const Unique<VkFramebuffer> framebuffer (createFramebuffer(vk, vkDevice, &framebufferParams));
1251 const VkCommandPoolCreateInfo cmdPoolParams =
1253 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
1255 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // flags
1256 queueFamilyIndex, // queueFamilyIndex
1258 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, vkDevice, &cmdPoolParams));
1261 const VkCommandBufferAllocateInfo cmdBufParams =
1263 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
1266 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
1269 const Unique<VkCommandBuffer> cmdBuf (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
1271 const VkCommandBufferBeginInfo cmdBufBeginParams =
1273 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
1276 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1280 VK_CHECK(vk.beginCommandBuffer(*cmdBuf, &cmdBufBeginParams));
1283 const VkMemoryBarrier vertFlushBarrier =
1285 VK_STRUCTURE_TYPE_MEMORY_BARRIER, // sType
1287 VK_ACCESS_HOST_WRITE_BIT, // srcAccessMask
1288 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, // dstAccessMask
1290 const VkImageMemoryBarrier colorAttBarrier =
1292 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
1294 0u, // srcAccessMask
1295 (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|
1296 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT), // dstAccessMask
1297 VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
1298 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
1299 queueFamilyIndex, // srcQueueFamilyIndex
1300 queueFamilyIndex, // dstQueueFamilyIndex
1303 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1306 0u, // baseArrayLayer
1308 } // subresourceRange
1310 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);
1314 const VkClearValue clearValue = makeClearValueColorF32(clearColor[0],
1318 const VkRenderPassBeginInfo passBeginParams =
1320 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // sType
1322 *renderPass, // renderPass
1323 *framebuffer, // framebuffer
1326 { (deUint32)renderSize.x(), (deUint32)renderSize.y() }
1328 1u, // clearValueCount
1329 &clearValue, // pClearValues
1331 vk.cmdBeginRenderPass(*cmdBuf, &passBeginParams, VK_SUBPASS_CONTENTS_INLINE);
1334 vk.cmdBindPipeline(*cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
1336 const VkDeviceSize bindingOffset = 0;
1337 vk.cmdBindVertexBuffers(*cmdBuf, 0u, 1u, &vertexBuffer.get(), &bindingOffset);
1339 vk.cmdDraw(*cmdBuf, 3u, 1u, 0u, 0u);
1340 vk.cmdEndRenderPass(*cmdBuf);
1343 const VkImageMemoryBarrier renderFinishBarrier =
1345 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
1347 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // outputMask
1348 VK_ACCESS_TRANSFER_READ_BIT, // inputMask
1349 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // oldLayout
1350 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // newLayout
1351 queueFamilyIndex, // srcQueueFamilyIndex
1352 queueFamilyIndex, // dstQueueFamilyIndex
1355 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1358 0u, // baseArraySlice
1360 } // subresourceRange
1362 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &renderFinishBarrier);
1366 const VkBufferImageCopy copyParams =
1368 (VkDeviceSize)0u, // bufferOffset
1369 (deUint32)renderSize.x(), // bufferRowLength
1370 (deUint32)renderSize.y(), // bufferImageHeight
1372 VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
1374 0u, // baseArrayLayer
1376 }, // imageSubresource
1377 { 0u, 0u, 0u }, // imageOffset
1379 (deUint32)renderSize.x(),
1380 (deUint32)renderSize.y(),
1384 vk.cmdCopyImageToBuffer(*cmdBuf, *image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *readImageBuffer, 1u, ©Params);
1388 const VkBufferMemoryBarrier copyFinishBarrier =
1390 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // sType
1392 VK_ACCESS_TRANSFER_WRITE_BIT, // srcAccessMask
1393 VK_ACCESS_HOST_READ_BIT, // dstAccessMask
1394 queueFamilyIndex, // srcQueueFamilyIndex
1395 queueFamilyIndex, // dstQueueFamilyIndex
1396 *readImageBuffer, // buffer
1398 imageSizeBytes // size
1400 vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©FinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1403 VK_CHECK(vk.endCommandBuffer(*cmdBuf));
1405 // Upload vertex data
1407 const VkMappedMemoryRange range =
1409 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, // sType
1411 vertexBufferMemory->getMemory(), // memory
1413 (VkDeviceSize)sizeof(vertices), // size
1415 void* vertexBufPtr = vertexBufferMemory->getHostPtr();
1417 deMemcpy(vertexBufPtr, &vertices[0], sizeof(vertices));
1418 VK_CHECK(vk.flushMappedMemoryRanges(vkDevice, 1u, &range));
1421 // Submit & wait for completion
1423 const VkFenceCreateInfo fenceParams =
1425 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // sType
1429 const VkSubmitInfo submitInfo =
1431 VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
1433 0u, // waitSemaphoreCount
1434 DE_NULL, // pWaitSemaphores
1435 (const VkPipelineStageFlags*)DE_NULL,
1436 1u, // commandBufferCount
1437 &cmdBuf.get(), // pCommandBuffers
1438 0u, // signalSemaphoreCount
1439 DE_NULL, // pSignalSemaphores
1441 const Unique<VkFence> fence (createFence(vk, vkDevice, &fenceParams));
1443 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
1444 VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
1447 // Read results, render reference, compare
1449 const tcu::TextureFormat tcuFormat = vk::mapVkFormat(colorFormat);
1450 const VkMappedMemoryRange range =
1452 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, // sType
1454 readImageBufferMemory->getMemory(), // memory
1456 imageSizeBytes, // size
1458 const tcu::ConstPixelBufferAccess resultAccess (tcuFormat, renderSize.x(), renderSize.y(), 1, readImageBufferMemory->getHostPtr());
1460 VK_CHECK(vk.invalidateMappedMemoryRanges(vkDevice, 1u, &range));
1463 tcu::TextureLevel refImage (tcuFormat, renderSize.x(), renderSize.y());
1464 const tcu::UVec4 threshold (0u);
1465 const tcu::IVec3 posDeviation (1,1,0);
1467 tcu::clear(refImage.getAccess(), clearColor);
1468 renderReferenceTriangle(refImage.getAccess(), vertices);
1470 if (tcu::intThresholdPositionDeviationCompare(context.getTestContext().getLog(),
1472 "Image comparison result",
1473 refImage.getAccess(),
1478 tcu::COMPARE_LOG_RESULT))
1479 return tcu::TestStatus::pass("Rendering succeeded");
1481 return tcu::TestStatus::fail("Image comparison failed");
1485 return tcu::TestStatus::pass("Rendering succeeded");
1490 tcu::TestCaseGroup* createSmokeTests (tcu::TestContext& testCtx)
1492 de::MovePtr<tcu::TestCaseGroup> smokeTests (new tcu::TestCaseGroup(testCtx, "smoke", "Smoke Tests"));
1494 addFunctionCase (smokeTests.get(), "create_sampler", "", createSamplerTest);
1495 addFunctionCaseWithPrograms (smokeTests.get(), "create_shader", "", createShaderProgs, createShaderModuleTest);
1496 addFunctionCaseWithPrograms (smokeTests.get(), "triangle", "", createTriangleProgs, renderTriangleTest);
1497 addFunctionCaseWithPrograms (smokeTests.get(), "asm_triangle", "", createTriangleAsmProgs, renderTriangleTest);
1498 addFunctionCaseWithPrograms (smokeTests.get(), "unused_resolve_attachment", "", createTriangleProgs, renderTriangleUnusedResolveAttachmentTest);
1500 return smokeTests.release();