1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2014 The Android Open Source Project
6 * Copyright (c) 2016 The Khronos Group Inc.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief Geometry Utilities
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktGeometryTestsUtil.hpp"
26 #include "vkTypeUtil.hpp"
27 #include "vkImageUtil.hpp"
28 #include "vkDefs.hpp"
29 #include "tcuImageCompare.hpp"
30
31 #include "tcuImageIO.hpp"
32
33 #include "deMath.h"
34
35 using namespace vk;
36
37 namespace vkt
38 {
39 namespace geometry
40 {
41
setShader(const DeviceInterface & vk,const VkDevice device,const VkShaderStageFlagBits stage,const ProgramBinary & binary,const VkSpecializationInfo * specInfo)42 GraphicsPipelineBuilder &GraphicsPipelineBuilder::setShader(const DeviceInterface &vk, const VkDevice device,
43 const VkShaderStageFlagBits stage,
44 const ProgramBinary &binary,
45 const VkSpecializationInfo *specInfo)
46 {
47 VkShaderModule module;
48 switch (stage)
49 {
50 case (VK_SHADER_STAGE_VERTEX_BIT):
51 DE_ASSERT(m_vertexShaderModule.get() == DE_NULL);
52 m_vertexShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
53 module = *m_vertexShaderModule;
54 break;
55
56 case (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT):
57 DE_ASSERT(m_tessControlShaderModule.get() == DE_NULL);
58 m_tessControlShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
59 module = *m_tessControlShaderModule;
60 break;
61
62 case (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT):
63 DE_ASSERT(m_tessEvaluationShaderModule.get() == DE_NULL);
64 m_tessEvaluationShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
65 module = *m_tessEvaluationShaderModule;
66 break;
67
68 case (VK_SHADER_STAGE_GEOMETRY_BIT):
69 DE_ASSERT(m_geometryShaderModule.get() == DE_NULL);
70 m_geometryShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
71 module = *m_geometryShaderModule;
72 break;
73
74 case (VK_SHADER_STAGE_FRAGMENT_BIT):
75 DE_ASSERT(m_fragmentShaderModule.get() == DE_NULL);
76 m_fragmentShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
77 module = *m_fragmentShaderModule;
78 break;
79
80 default:
81 DE_FATAL("Invalid shader stage");
82 return *this;
83 }
84
85 const VkPipelineShaderStageCreateInfo pipelineShaderStageInfo = {
86 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
87 DE_NULL, // const void* pNext;
88 (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
89 stage, // VkShaderStageFlagBits stage;
90 module, // VkShaderModule module;
91 "main", // const char* pName;
92 specInfo, // const VkSpecializationInfo* pSpecializationInfo;
93 };
94
95 m_shaderStageFlags |= stage;
96 m_shaderStages.push_back(pipelineShaderStageInfo);
97
98 return *this;
99 }
100
setVertexInputSingleAttribute(const VkFormat vertexFormat,const uint32_t stride)101 GraphicsPipelineBuilder &GraphicsPipelineBuilder::setVertexInputSingleAttribute(const VkFormat vertexFormat,
102 const uint32_t stride)
103 {
104 const VkVertexInputBindingDescription bindingDesc = {
105 0u, // uint32_t binding;
106 stride, // uint32_t stride;
107 VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate;
108 };
109 const VkVertexInputAttributeDescription attributeDesc = {
110 0u, // uint32_t location;
111 0u, // uint32_t binding;
112 vertexFormat, // VkFormat format;
113 0u, // uint32_t offset;
114 };
115
116 m_vertexInputBindings.clear();
117 m_vertexInputBindings.push_back(bindingDesc);
118
119 m_vertexInputAttributes.clear();
120 m_vertexInputAttributes.push_back(attributeDesc);
121
122 return *this;
123 }
124
125 template <typename T>
dataPointer(const std::vector<T> & vec)126 inline const T *dataPointer(const std::vector<T> &vec)
127 {
128 return (vec.size() != 0 ? &vec[0] : DE_NULL);
129 }
130
build(const DeviceInterface & vk,const VkDevice device,const VkPipelineLayout pipelineLayout,const VkRenderPass renderPass)131 Move<VkPipeline> GraphicsPipelineBuilder::build(const DeviceInterface &vk, const VkDevice device,
132 const VkPipelineLayout pipelineLayout, const VkRenderPass renderPass)
133 {
134 const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo = {
135 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
136 DE_NULL, // const void* pNext;
137 (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
138 static_cast<uint32_t>(
139 m_vertexInputBindings.size()), // uint32_t vertexBindingDescriptionCount;
140 dataPointer(m_vertexInputBindings), // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
141 static_cast<uint32_t>(
142 m_vertexInputAttributes
143 .size()), // uint32_t vertexAttributeDescriptionCount;
144 dataPointer(
145 m_vertexInputAttributes), // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
146 };
147
148 const VkPrimitiveTopology topology = (m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ?
149 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST :
150 m_primitiveTopology;
151
152 VkBool32 primitiveRestartEnable = VK_TRUE;
153 switch (m_primitiveTopology)
154 {
155 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
156 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
157 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
158 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
159 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
160 case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
161 primitiveRestartEnable = VK_FALSE;
162 break;
163 default:
164 break;
165 }
166
167 const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo = {
168 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
169 DE_NULL, // const void* pNext;
170 (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
171 topology, // VkPrimitiveTopology topology;
172 primitiveRestartEnable, // VkBool32 primitiveRestartEnable;
173 };
174
175 const VkPipelineTessellationStateCreateInfo pipelineTessellationStateInfo = {
176 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType;
177 DE_NULL, // const void* pNext;
178 (VkPipelineTessellationStateCreateFlags)0, // VkPipelineTessellationStateCreateFlags flags;
179 m_patchControlPoints, // uint32_t patchControlPoints;
180 };
181
182 const VkViewport viewport = makeViewport(m_renderSize);
183 const VkRect2D scissor = makeRect2D(m_renderSize);
184
185 const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo = {
186 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
187 DE_NULL, // const void* pNext;
188 (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
189 1u, // uint32_t viewportCount;
190 &viewport, // const VkViewport* pViewports;
191 1u, // uint32_t scissorCount;
192 &scissor, // const VkRect2D* pScissors;
193 };
194
195 const bool isRasterizationDisabled = ((m_shaderStageFlags & VK_SHADER_STAGE_FRAGMENT_BIT) == 0);
196 const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo = {
197 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
198 DE_NULL, // const void* pNext;
199 (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
200 VK_FALSE, // VkBool32 depthClampEnable;
201 isRasterizationDisabled, // VkBool32 rasterizerDiscardEnable;
202 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
203 m_cullModeFlags, // VkCullModeFlags cullMode;
204 m_frontFace, // VkFrontFace frontFace;
205 VK_FALSE, // VkBool32 depthBiasEnable;
206 0.0f, // float depthBiasConstantFactor;
207 0.0f, // float depthBiasClamp;
208 0.0f, // float depthBiasSlopeFactor;
209 1.0f, // float lineWidth;
210 };
211
212 const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo = {
213 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
214 DE_NULL, // const void* pNext;
215 (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
216 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
217 VK_FALSE, // VkBool32 sampleShadingEnable;
218 0.0f, // float minSampleShading;
219 DE_NULL, // const VkSampleMask* pSampleMask;
220 VK_FALSE, // VkBool32 alphaToCoverageEnable;
221 VK_FALSE // VkBool32 alphaToOneEnable;
222 };
223
224 const VkStencilOpState stencilOpState = makeStencilOpState(VK_STENCIL_OP_KEEP, // stencil fail
225 VK_STENCIL_OP_KEEP, // depth & stencil pass
226 VK_STENCIL_OP_KEEP, // depth only fail
227 VK_COMPARE_OP_NEVER, // compare op
228 0u, // compare mask
229 0u, // write mask
230 0u); // reference
231
232 const VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo = {
233 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
234 DE_NULL, // const void* pNext;
235 (VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags;
236 VK_FALSE, // VkBool32 depthTestEnable;
237 VK_FALSE, // VkBool32 depthWriteEnable;
238 VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
239 VK_FALSE, // VkBool32 depthBoundsTestEnable;
240 VK_FALSE, // VkBool32 stencilTestEnable;
241 stencilOpState, // VkStencilOpState front;
242 stencilOpState, // VkStencilOpState back;
243 0.0f, // float minDepthBounds;
244 1.0f, // float maxDepthBounds;
245 };
246
247 const VkColorComponentFlags colorComponentsAll =
248 VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
249 const VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState = {
250 m_blendEnable, // VkBool32 blendEnable;
251 VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcColorBlendFactor;
252 VK_BLEND_FACTOR_ONE, // VkBlendFactor dstColorBlendFactor;
253 VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
254 VK_BLEND_FACTOR_SRC_ALPHA, // VkBlendFactor srcAlphaBlendFactor;
255 VK_BLEND_FACTOR_ONE, // VkBlendFactor dstAlphaBlendFactor;
256 VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
257 colorComponentsAll, // VkColorComponentFlags colorWriteMask;
258 };
259
260 const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo = {
261 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
262 DE_NULL, // const void* pNext;
263 (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
264 VK_FALSE, // VkBool32 logicOpEnable;
265 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
266 1u, // uint32_t attachmentCount;
267 &pipelineColorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
268 {0.0f, 0.0f, 0.0f, 0.0f}, // float blendConstants[4];
269 };
270
271 const VkGraphicsPipelineCreateInfo graphicsPipelineInfo = {
272 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
273 DE_NULL, // const void* pNext;
274 (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
275 static_cast<uint32_t>(m_shaderStages.size()), // uint32_t stageCount;
276 &m_shaderStages[0], // const VkPipelineShaderStageCreateInfo* pStages;
277 &vertexInputStateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
278 &pipelineInputAssemblyStateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
279 (m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ?
280 &pipelineTessellationStateInfo :
281 DE_NULL), // const VkPipelineTessellationStateCreateInfo* pTessellationState;
282 (isRasterizationDisabled ?
283 DE_NULL :
284 &pipelineViewportStateInfo), // const VkPipelineViewportStateCreateInfo* pViewportState;
285 &pipelineRasterizationStateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
286 (isRasterizationDisabled ?
287 DE_NULL :
288 &pipelineMultisampleStateInfo), // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
289 (isRasterizationDisabled ?
290 DE_NULL :
291 &pipelineDepthStencilStateInfo), // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
292 (isRasterizationDisabled ?
293 DE_NULL :
294 &pipelineColorBlendStateInfo), // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
295 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
296 pipelineLayout, // VkPipelineLayout layout;
297 renderPass, // VkRenderPass renderPass;
298 0u, // uint32_t subpass;
299 DE_NULL, // VkPipeline basePipelineHandle;
300 0, // int32_t basePipelineIndex;
301 };
302
303 return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
304 }
305
inputTypeToGLString(const VkPrimitiveTopology & inputType)306 std::string inputTypeToGLString(const VkPrimitiveTopology &inputType)
307 {
308 switch (inputType)
309 {
310 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
311 return "points";
312 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
313 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
314 return "lines";
315 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
316 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
317 return "lines_adjacency";
318 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
319 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
320 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
321 return "triangles";
322 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
323 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
324 return "triangles_adjacency";
325 default:
326 DE_ASSERT(false);
327 return "error";
328 }
329 }
330
outputTypeToGLString(const VkPrimitiveTopology & outputType)331 std::string outputTypeToGLString(const VkPrimitiveTopology &outputType)
332 {
333 switch (outputType)
334 {
335 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
336 return "points";
337 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
338 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
339 return "line_strip";
340 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
341 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
342 return "triangle_strip";
343 default:
344 DE_ASSERT(false);
345 return "error";
346 }
347 }
348
calcOutputVertices(const VkPrimitiveTopology & inputType)349 size_t calcOutputVertices(const VkPrimitiveTopology &inputType)
350 {
351 switch (inputType)
352 {
353 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
354 return 1 * 3;
355 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
356 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
357 return 2 * 3;
358 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
359 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
360 return 4 * 3;
361 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
362 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
363 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
364 return 3 * 3;
365 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
366 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
367 return 6 * 3;
368 default:
369 DE_ASSERT(false);
370 return 0;
371 }
372 }
373
makeImageCreateInfo(const tcu::IVec2 & size,const VkFormat format,const VkImageUsageFlags usage,const uint32_t numArrayLayers)374 VkImageCreateInfo makeImageCreateInfo(const tcu::IVec2 &size, const VkFormat format, const VkImageUsageFlags usage,
375 const uint32_t numArrayLayers)
376 {
377 const VkImageCreateInfo imageInfo = {
378 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
379 DE_NULL, // const void* pNext;
380 (VkImageCreateFlags)0, // VkImageCreateFlags flags;
381 VK_IMAGE_TYPE_2D, // VkImageType imageType;
382 format, // VkFormat format;
383 makeExtent3D(size.x(), size.y(), 1), // VkExtent3D extent;
384 1u, // uint32_t mipLevels;
385 numArrayLayers, // uint32_t arrayLayers;
386 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
387 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
388 usage, // VkImageUsageFlags usage;
389 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
390 0u, // uint32_t queueFamilyIndexCount;
391 DE_NULL, // const uint32_t* pQueueFamilyIndices;
392 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
393 };
394 return imageInfo;
395 }
396
makeBufferImageCopy(const vk::VkDeviceSize & bufferOffset,const vk::VkImageSubresourceLayers & imageSubresource,const vk::VkOffset3D & imageOffset,const vk::VkExtent3D & imageExtent)397 VkBufferImageCopy makeBufferImageCopy(const vk::VkDeviceSize &bufferOffset,
398 const vk::VkImageSubresourceLayers &imageSubresource,
399 const vk::VkOffset3D &imageOffset, const vk::VkExtent3D &imageExtent)
400 {
401 const VkBufferImageCopy copyParams = {
402 bufferOffset, // VkDeviceSize bufferOffset;
403 0u, // uint32_t bufferRowLength;
404 0u, // uint32_t bufferImageHeight;
405 imageSubresource, // VkImageSubresourceLayers imageSubresource;
406 imageOffset, // VkOffset3D imageOffset;
407 imageExtent, // VkExtent3D imageExtent;
408 };
409 return copyParams;
410 }
411
compareWithFileImage(Context & context,const tcu::ConstPixelBufferAccess & resultImage,std::string testName)412 bool compareWithFileImage(Context &context, const tcu::ConstPixelBufferAccess &resultImage, std::string testName)
413 {
414 tcu::TextureLevel referenceImage;
415 std::string fileName = "vulkan/data/geometry/" + testName + ".png";
416 tcu::ImageIO::loadPNG(referenceImage, context.getTestContext().getArchive(), fileName.c_str());
417
418 if (tcu::fuzzyCompare(context.getTestContext().getLog(), "ImageComparison", "Image Comparison",
419 referenceImage.getAccess(), resultImage, 0.0015f, tcu::COMPARE_LOG_RESULT))
420 return tcu::intThresholdPositionDeviationCompare(
421 context.getTestContext().getLog(), "ImageComparison", "Image Comparison", referenceImage.getAccess(),
422 resultImage, tcu::UVec4(1u, 1u, 1u, 1u), tcu::IVec3(2, 2, 2), false, tcu::COMPARE_LOG_RESULT);
423 else
424 return false;
425 }
426
fillBuffer(const DeviceInterface & vk,const VkDevice device,const Allocation & alloc,const VkDeviceSize offset,const VkDeviceSize size,const VkFormat format,const tcu::Vec4 & color)427 void fillBuffer(const DeviceInterface &vk, const VkDevice device, const Allocation &alloc, const VkDeviceSize offset,
428 const VkDeviceSize size, const VkFormat format, const tcu::Vec4 &color)
429 {
430 const tcu::TextureFormat textureFormat = mapVkFormat(format);
431 const uint32_t colorPixelSize = static_cast<uint32_t>(tcu::getPixelSize(textureFormat));
432 tcu::TextureLevel colorPixelBuffer(textureFormat, 1, 1);
433 tcu::PixelBufferAccess colorPixel(colorPixelBuffer);
434
435 colorPixel.setPixel(color, 0, 0);
436
437 const uint8_t *src = static_cast<uint8_t *>(colorPixel.getDataPtr());
438 uint8_t *dstBase = static_cast<uint8_t *>(alloc.getHostPtr());
439 uint8_t *dst = &dstBase[offset];
440
441 for (uint32_t pixelPos = 0; pixelPos < size; pixelPos += colorPixelSize)
442 deMemcpy(&dst[pixelPos], src, colorPixelSize);
443
444 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset() + offset, size);
445 }
446
fillBuffer(const DeviceInterface & vk,const VkDevice device,const Allocation & alloc,const VkDeviceSize offset,const VkDeviceSize size,const VkFormat format,const float depth)447 void fillBuffer(const DeviceInterface &vk, const VkDevice device, const Allocation &alloc, const VkDeviceSize offset,
448 const VkDeviceSize size, const VkFormat format, const float depth)
449 {
450 const tcu::TextureFormat textureFormat = mapVkFormat(format);
451 const uint32_t colorPixelSize = static_cast<uint32_t>(tcu::getPixelSize(textureFormat));
452 tcu::TextureLevel colorPixelBuffer(textureFormat, 1, 1);
453 tcu::PixelBufferAccess colorPixel(colorPixelBuffer);
454
455 colorPixel.setPixDepth(depth, 0, 0);
456
457 const uint8_t *src = static_cast<uint8_t *>(colorPixel.getDataPtr());
458 uint8_t *dstBase = static_cast<uint8_t *>(alloc.getHostPtr());
459 uint8_t *dst = &dstBase[offset];
460
461 for (uint32_t pixelPos = 0; pixelPos < size; pixelPos += colorPixelSize)
462 deMemcpy(&dst[pixelPos], src, colorPixelSize);
463
464 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset() + offset, size);
465 }
466
checkPointSize(const InstanceInterface & vki,const VkPhysicalDevice physDevice)467 VkBool32 checkPointSize(const InstanceInterface &vki, const VkPhysicalDevice physDevice)
468 {
469 const VkPhysicalDeviceFeatures features = getPhysicalDeviceFeatures(vki, physDevice);
470 return features.shaderTessellationAndGeometryPointSize;
471 }
472
473 } // namespace geometry
474 } // namespace vkt
475