1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2016 The Khronos Group Inc.
6 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
7 * Copyright (c) 2014 The Android Open Source Project
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
23 * \brief Texture test utilities.
24 *//*--------------------------------------------------------------------*/
26 #include "vktTextureTestUtil.hpp"
28 #include "deFilePath.hpp"
30 #include "tcuCompressedTexture.hpp"
31 #include "tcuImageIO.hpp"
32 #include "tcuStringTemplate.hpp"
33 #include "tcuTestLog.hpp"
34 #include "vkBuilderUtil.hpp"
35 #include "vkImageUtil.hpp"
36 #include "vkPrograms.hpp"
37 #include "vkQueryUtil.hpp"
38 #include "vkRefUtil.hpp"
39 #include "vkTypeUtil.hpp"
47 using namespace glu::TextureTestUtil;
56 deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
58 const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(vkInstance, physicalDevice);
60 for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
62 if ((queueProps[queueNdx].queueFlags & requiredCaps) == requiredCaps)
63 return (deUint32)queueNdx;
66 TCU_THROW(NotSupportedError, "No matching queue found");
69 struct ShaderParameters {
70 float bias; //!< User-supplied bias.
71 float ref; //!< Reference value for shadow lookups.
72 tcu::Vec2 padding; //!< Shader uniform padding.
73 tcu::Vec4 colorScale; //!< Scale for texture color values.
74 tcu::Vec4 colorBias; //!< Bias for texture color values.
77 const char* getProgramName(Program program)
81 case PROGRAM_2D_FLOAT: return "2D_FLOAT";
82 case PROGRAM_2D_INT: return "2D_INT";
83 case PROGRAM_2D_UINT: return "2D_UINT";
84 case PROGRAM_2D_SHADOW: return "2D_SHADOW";
85 case PROGRAM_2D_FLOAT_BIAS: return "2D_FLOAT_BIAS";
86 case PROGRAM_2D_INT_BIAS: return "2D_INT_BIAS";
87 case PROGRAM_2D_UINT_BIAS: return "2D_UINT_BIAS";
88 case PROGRAM_2D_SHADOW_BIAS: return "2D_SHADOW_BIAS";
89 case PROGRAM_1D_FLOAT: return "1D_FLOAT";
90 case PROGRAM_1D_INT: return "1D_INT";
91 case PROGRAM_1D_UINT: return "1D_UINT";
92 case PROGRAM_1D_SHADOW: return "1D_SHADOW";
93 case PROGRAM_1D_FLOAT_BIAS: return "1D_FLOAT_BIAS";
94 case PROGRAM_1D_INT_BIAS: return "1D_INT_BIAS";
95 case PROGRAM_1D_UINT_BIAS: return "1D_UINT_BIAS";
96 case PROGRAM_1D_SHADOW_BIAS: return "1D_SHADOW_BIAS";
97 case PROGRAM_CUBE_FLOAT: return "CUBE_FLOAT";
98 case PROGRAM_CUBE_INT: return "CUBE_INT";
99 case PROGRAM_CUBE_UINT: return "CUBE_UINT";
100 case PROGRAM_CUBE_SHADOW: return "CUBE_SHADOW";
101 case PROGRAM_CUBE_FLOAT_BIAS: return "CUBE_FLOAT_BIAS";
102 case PROGRAM_CUBE_INT_BIAS: return "CUBE_INT_BIAS";
103 case PROGRAM_CUBE_UINT_BIAS: return "CUBE_UINT_BIAS";
104 case PROGRAM_CUBE_SHADOW_BIAS: return "CUBE_SHADOW_BIAS";
105 case PROGRAM_2D_ARRAY_FLOAT: return "2D_ARRAY_FLOAT";
106 case PROGRAM_2D_ARRAY_INT: return "2D_ARRAY_INT";
107 case PROGRAM_2D_ARRAY_UINT: return "2D_ARRAY_UINT";
108 case PROGRAM_2D_ARRAY_SHADOW: return "2D_ARRAY_SHADOW";
109 case PROGRAM_3D_FLOAT: return "3D_FLOAT";
110 case PROGRAM_3D_INT: return "3D_INT";
111 case PROGRAM_3D_UINT: return "3D_UINT";
112 case PROGRAM_3D_FLOAT_BIAS: return "3D_FLOAT_BIAS";
113 case PROGRAM_3D_INT_BIAS: return "3D_INT_BIAS";
114 case PROGRAM_3D_UINT_BIAS: return "3D_UINT_BIAS";
115 case PROGRAM_CUBE_ARRAY_FLOAT: return "CUBE_ARRAY_FLOAT";
116 case PROGRAM_CUBE_ARRAY_INT: return "CUBE_ARRAY_INT";
117 case PROGRAM_CUBE_ARRAY_UINT: return "CUBE_ARRAY_UINT";
118 case PROGRAM_CUBE_ARRAY_SHADOW: return "CUBE_ARRAY_SHADOW";
119 case PROGRAM_1D_ARRAY_FLOAT: return "1D_ARRAY_FLOAT";
120 case PROGRAM_1D_ARRAY_INT: return "1D_ARRAY_INT";
121 case PROGRAM_1D_ARRAY_UINT: return "1D_ARRAY_UINT";
122 case PROGRAM_1D_ARRAY_SHADOW: return "1D_ARRAY_SHADOW";
123 case PROGRAM_BUFFER_FLOAT: return "BUFFER_FLOAT";
124 case PROGRAM_BUFFER_INT: return "BUFFER_INT";
125 case PROGRAM_BUFFER_UINT: return "BUFFER_UINT";
132 VkImageViewType textureTypeToImageViewType (TextureBinding::Type type)
136 case TextureBinding::TYPE_2D: return VK_IMAGE_VIEW_TYPE_2D;
137 case TextureBinding::TYPE_2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
138 case TextureBinding::TYPE_CUBE_MAP: return VK_IMAGE_VIEW_TYPE_CUBE;
139 case TextureBinding::TYPE_3D: return VK_IMAGE_VIEW_TYPE_3D;
144 return VK_IMAGE_VIEW_TYPE_2D;
147 VkImageType imageViewTypeToImageType (VkImageViewType type)
151 case VK_IMAGE_VIEW_TYPE_2D:
152 case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
153 case VK_IMAGE_VIEW_TYPE_CUBE: return VK_IMAGE_TYPE_2D;
154 case VK_IMAGE_VIEW_TYPE_3D: return VK_IMAGE_TYPE_3D;
159 return VK_IMAGE_TYPE_2D;
162 void initializePrograms(vk::SourceCollections& programCollection, glu::Precision texCoordPrecision, const std::vector<Program>& programs)
164 static const char* vertShaderTemplate =
166 "layout(location = 0) ${VTX_IN} highp vec4 a_position;\n"
167 "layout(location = 1) ${VTX_IN} ${PRECISION} ${TEXCOORD_TYPE} a_texCoord;\n"
168 "layout(location = 0) ${VTX_OUT} ${PRECISION} ${TEXCOORD_TYPE} v_texCoord;\n"
169 "${VTX_OUT} gl_PerVertex { vec4 gl_Position; };\n"
173 " gl_Position = a_position;\n"
174 " v_texCoord = a_texCoord;\n"
177 static const char* fragShaderTemplate =
179 "layout(location = 0) ${FRAG_IN} ${PRECISION} ${TEXCOORD_TYPE} v_texCoord;\n"
180 "layout(location = 0) out mediump vec4 ${FRAG_COLOR};\n"
181 "layout (set=0, binding=0, std140) uniform Block \n"
183 " ${PRECISION} float u_bias;\n"
184 " ${PRECISION} float u_ref;\n"
185 " ${PRECISION} vec4 u_colorScale;\n"
186 " ${PRECISION} vec4 u_colorBias;\n"
188 "layout (set=1, binding=0) uniform ${PRECISION} ${SAMPLER_TYPE} u_sampler;\n"
191 " ${FRAG_COLOR} = ${LOOKUP} * u_colorScale + u_colorBias;\n"
194 tcu::StringTemplate vertexSource (vertShaderTemplate);
195 tcu::StringTemplate fragmentSource (fragShaderTemplate);
197 for (std::vector<Program>::const_iterator programIt = programs.begin(); programIt != programs.end(); ++programIt)
199 Program program = *programIt;
200 std::map<std::string, std::string> params;
202 bool isCube = de::inRange<int>(program, PROGRAM_CUBE_FLOAT, PROGRAM_CUBE_SHADOW_BIAS);
203 bool isArray = de::inRange<int>(program, PROGRAM_2D_ARRAY_FLOAT, PROGRAM_2D_ARRAY_SHADOW)
204 || de::inRange<int>(program, PROGRAM_1D_ARRAY_FLOAT, PROGRAM_1D_ARRAY_SHADOW);
206 bool is1D = de::inRange<int>(program, PROGRAM_1D_FLOAT, PROGRAM_1D_SHADOW_BIAS)
207 || de::inRange<int>(program, PROGRAM_1D_ARRAY_FLOAT, PROGRAM_1D_ARRAY_SHADOW)
208 || de::inRange<int>(program, PROGRAM_BUFFER_FLOAT, PROGRAM_BUFFER_UINT);
210 bool is2D = de::inRange<int>(program, PROGRAM_2D_FLOAT, PROGRAM_2D_SHADOW_BIAS)
211 || de::inRange<int>(program, PROGRAM_2D_ARRAY_FLOAT, PROGRAM_2D_ARRAY_SHADOW);
213 bool is3D = de::inRange<int>(program, PROGRAM_3D_FLOAT, PROGRAM_3D_UINT_BIAS);
214 bool isCubeArray = de::inRange<int>(program, PROGRAM_CUBE_ARRAY_FLOAT, PROGRAM_CUBE_ARRAY_SHADOW);
216 const std::string version = glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450);
218 params["FRAG_HEADER"] = version + "\n";
219 params["VTX_HEADER"] = version + "\n";
220 params["VTX_IN"] = "in";
221 params["VTX_OUT"] = "out";
222 params["FRAG_IN"] = "in";
223 params["FRAG_COLOR"] = "dEQP_FragColor";
225 params["PRECISION"] = glu::getPrecisionName(texCoordPrecision);
228 params["TEXCOORD_TYPE"] = "vec4";
229 else if (isCube || (is2D && isArray) || is3D)
230 params["TEXCOORD_TYPE"] = "vec3";
231 else if ((is1D && isArray) || is2D)
232 params["TEXCOORD_TYPE"] = "vec2";
234 params["TEXCOORD_TYPE"] = "float";
238 const char* sampler = DE_NULL;
239 const char* lookup = DE_NULL;
243 case PROGRAM_2D_FLOAT: sampler = "sampler2D"; lookup = "texture(u_sampler, v_texCoord)"; break;
244 case PROGRAM_2D_INT: sampler = "isampler2D"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
245 case PROGRAM_2D_UINT: sampler = "usampler2D"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
246 case PROGRAM_2D_SHADOW: sampler = "sampler2DShadow"; lookup = "vec4(texture(u_sampler, vec3(v_texCoord, u_ref)), 0.0, 0.0, 1.0)"; break;
247 case PROGRAM_2D_FLOAT_BIAS: sampler = "sampler2D"; lookup = "texture(u_sampler, v_texCoord, u_bias)"; break;
248 case PROGRAM_2D_INT_BIAS: sampler = "isampler2D"; lookup = "vec4(texture(u_sampler, v_texCoord, u_bias))"; break;
249 case PROGRAM_2D_UINT_BIAS: sampler = "usampler2D"; lookup = "vec4(texture(u_sampler, v_texCoord, u_bias))"; break;
250 case PROGRAM_2D_SHADOW_BIAS: sampler = "sampler2DShadow"; lookup = "vec4(texture(u_sampler, vec3(v_texCoord, u_ref), u_bias), 0.0, 0.0, 1.0)"; break;
251 case PROGRAM_1D_FLOAT: sampler = "sampler1D"; lookup = "texture(u_sampler, v_texCoord)"; break;
252 case PROGRAM_1D_INT: sampler = "isampler1D"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
253 case PROGRAM_1D_UINT: sampler = "usampler1D"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
254 case PROGRAM_1D_SHADOW: sampler = "sampler1DShadow"; lookup = "vec4(texture(u_sampler, vec3(v_texCoord, 0.0, u_ref)), 0.0, 0.0, 1.0)"; break;
255 case PROGRAM_1D_FLOAT_BIAS: sampler = "sampler1D"; lookup = "texture(u_sampler, v_texCoord, u_bias)"; break;
256 case PROGRAM_1D_INT_BIAS: sampler = "isampler1D"; lookup = "vec4(texture(u_sampler, v_texCoord, u_bias))"; break;
257 case PROGRAM_1D_UINT_BIAS: sampler = "usampler1D"; lookup = "vec4(texture(u_sampler, v_texCoord, u_bias))"; break;
258 case PROGRAM_1D_SHADOW_BIAS: sampler = "sampler1DShadow"; lookup = "vec4(texture(u_sampler, vec3(v_texCoord, 0.0, u_ref), u_bias), 0.0, 0.0, 1.0)"; break;
259 case PROGRAM_CUBE_FLOAT: sampler = "samplerCube"; lookup = "texture(u_sampler, v_texCoord)"; break;
260 case PROGRAM_CUBE_INT: sampler = "isamplerCube"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
261 case PROGRAM_CUBE_UINT: sampler = "usamplerCube"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
262 case PROGRAM_CUBE_SHADOW: sampler = "samplerCubeShadow"; lookup = "vec4(texture(u_sampler, vec4(v_texCoord, u_ref)), 0.0, 0.0, 1.0)"; break;
263 case PROGRAM_CUBE_FLOAT_BIAS: sampler = "samplerCube"; lookup = "texture(u_sampler, v_texCoord, u_bias)"; break;
264 case PROGRAM_CUBE_INT_BIAS: sampler = "isamplerCube"; lookup = "vec4(texture(u_sampler, v_texCoord, u_bias))"; break;
265 case PROGRAM_CUBE_UINT_BIAS: sampler = "usamplerCube"; lookup = "vec4(texture(u_sampler, v_texCoord, u_bias))"; break;
266 case PROGRAM_CUBE_SHADOW_BIAS: sampler = "samplerCubeShadow"; lookup = "vec4(texture(u_sampler, vec4(v_texCoord, u_ref), u_bias), 0.0, 0.0, 1.0)"; break;
267 case PROGRAM_2D_ARRAY_FLOAT: sampler = "sampler2DArray"; lookup = "texture(u_sampler, v_texCoord)"; break;
268 case PROGRAM_2D_ARRAY_INT: sampler = "isampler2DArray"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
269 case PROGRAM_2D_ARRAY_UINT: sampler = "usampler2DArray"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
270 case PROGRAM_2D_ARRAY_SHADOW: sampler = "sampler2DArrayShadow"; lookup = "vec4(texture(u_sampler, vec4(v_texCoord, u_ref)), 0.0, 0.0, 1.0)"; break;
271 case PROGRAM_3D_FLOAT: sampler = "sampler3D"; lookup = "texture(u_sampler, v_texCoord)"; break;
272 case PROGRAM_3D_INT: sampler = "isampler3D"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
273 case PROGRAM_3D_UINT: sampler = "usampler3D"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
274 case PROGRAM_3D_FLOAT_BIAS: sampler = "sampler3D"; lookup = "texture(u_sampler, v_texCoord, u_bias)"; break;
275 case PROGRAM_3D_INT_BIAS: sampler = "isampler3D"; lookup = "vec4(texture(u_sampler, v_texCoord, u_bias))"; break;
276 case PROGRAM_3D_UINT_BIAS: sampler = "usampler3D"; lookup = "vec4(texture(u_sampler, v_texCoord, u_bias))"; break;
277 case PROGRAM_CUBE_ARRAY_FLOAT: sampler = "samplerCubeArray"; lookup = "texture(u_sampler, v_texCoord)"; break;
278 case PROGRAM_CUBE_ARRAY_INT: sampler = "isamplerCubeArray"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
279 case PROGRAM_CUBE_ARRAY_UINT: sampler = "usamplerCubeArray"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
280 case PROGRAM_CUBE_ARRAY_SHADOW: sampler = "samplerCubeArrayShadow"; lookup = "vec4(texture(u_sampler, v_texCoord, u_ref), 0.0, 0.0, 1.0)"; break;
281 case PROGRAM_1D_ARRAY_FLOAT: sampler = "sampler1DArray"; lookup = "texture(u_sampler, v_texCoord)"; break;
282 case PROGRAM_1D_ARRAY_INT: sampler = "isampler1DArray"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
283 case PROGRAM_1D_ARRAY_UINT: sampler = "usampler1DArray"; lookup = "vec4(texture(u_sampler, v_texCoord))"; break;
284 case PROGRAM_1D_ARRAY_SHADOW: sampler = "sampler1DArrayShadow"; lookup = "vec4(texture(u_sampler, vec3(v_texCoord, u_ref)), 0.0, 0.0, 1.0)"; break;
285 case PROGRAM_BUFFER_FLOAT: sampler = "samplerBuffer"; lookup = "texelFetch(u_sampler, int(v_texCoord))"; break;
286 case PROGRAM_BUFFER_INT: sampler = "isamplerBuffer"; lookup = "vec4(texelFetch(u_sampler, int(v_texCoord)))"; break;
287 case PROGRAM_BUFFER_UINT: sampler = "usamplerBuffer"; lookup = "vec4(texelFetch(u_sampler, int(v_texCoord)))"; break;
292 params["SAMPLER_TYPE"] = sampler;
293 params["LOOKUP"] = lookup;
295 programCollection.glslSources.add("vertext_" + std::string(getProgramName(program))) << glu::VertexSource(vertexSource.specialize(params));
296 programCollection.glslSources.add("fragment_" + std::string(getProgramName(program))) << glu::FragmentSource(fragmentSource.specialize(params));
300 TextureBinding::TextureBinding (Context& context)
301 : m_context (context)
302 , m_queueFamilyIndex (findQueueFamilyIndexWithCaps(context.getInstanceInterface(), context.getPhysicalDevice(), VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_SPARSE_BINDING_BIT))
303 , m_device (createDevice())
304 , m_deviceInterface (context.getInstanceInterface(), *m_device)
305 , m_allocator (createAllocator())
309 TextureBinding::TextureBinding (Context& context, const TestTextureSp& textureData, const TextureBinding::Type type, const TextureBinding::ImageBackingMode backingMode)
310 : m_context (context)
311 , m_queueFamilyIndex (findQueueFamilyIndexWithCaps(context.getInstanceInterface(), context.getPhysicalDevice(), VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_SPARSE_BINDING_BIT))
313 , m_backingMode (backingMode)
314 , m_textureData (textureData)
315 , m_device (createDevice())
316 , m_deviceInterface (context.getInstanceInterface(), *m_device)
317 , m_allocator (createAllocator())
319 updateTextureData(m_textureData, m_type);
322 void TextureBinding::updateTextureData (const TestTextureSp& textureData, const TextureBinding::Type textureType)
324 const DeviceInterface& vkd = m_context.getDeviceInterface();
325 const VkDevice vkDevice = m_context.getDevice();
326 const bool sparse = m_backingMode == IMAGE_BACKING_MODE_SPARSE;
327 const deUint32 queueFamilyIndex = sparse ? m_queueFamilyIndex : m_context.getUniversalQueueFamilyIndex();
328 const VkQueue queue = sparse ? getDeviceQueue(vkd, vkDevice, queueFamilyIndex, 0) : m_context.getUniversalQueue();
329 Allocator& allocator = m_context.getDefaultAllocator();
330 m_type = textureType;
331 m_textureData = textureData;
333 const bool isCube = m_type == TYPE_CUBE_MAP;
334 VkImageCreateFlags imageCreateFlags = (isCube ? VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0) | (sparse ? (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) : 0);
335 const VkImageViewType imageViewType = textureTypeToImageViewType(textureType);
336 const VkImageType imageType = imageViewTypeToImageType(imageViewType);
337 const VkImageTiling imageTiling = VK_IMAGE_TILING_OPTIMAL;
338 const VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
339 const VkFormat format = textureData->isCompressed() ? mapCompressedTextureFormat(textureData->getCompressedLevel(0, 0).getFormat()) : mapTextureFormat(textureData->getTextureFormat());
340 const tcu::UVec3 textureDimension = textureData->getTextureDimension();
341 const deUint32 mipLevels = textureData->getNumLevels();
342 const deUint32 arraySize = textureData->getArraySize();
343 vk::VkImageFormatProperties imageFormatProperties;
344 const VkResult imageFormatQueryResult = m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(), format, imageType, imageTiling, imageUsageFlags, imageCreateFlags, &imageFormatProperties);
346 if (imageFormatQueryResult == VK_ERROR_FORMAT_NOT_SUPPORTED)
348 TCU_THROW(NotSupportedError, (std::string("Format not supported: ") + vk::getFormatName(format)).c_str());
351 VK_CHECK(imageFormatQueryResult);
353 if (imageFormatProperties.maxArrayLayers < arraySize)
354 TCU_THROW(NotSupportedError, ("Maximum array layers number for this format is not enough for this test."));
356 if (imageFormatProperties.maxMipLevels < mipLevels)
357 TCU_THROW(NotSupportedError, ("Maximum mimap level number for this format is not enough for this test."));
359 if (imageFormatProperties.maxExtent.width < textureDimension.x() ||
360 imageFormatProperties.maxExtent.height < textureDimension.y() ||
361 imageFormatProperties.maxExtent.depth < textureDimension.z())
363 TCU_THROW(NotSupportedError, ("Maximum image dimension for this format is not enough for this test."));
367 const VkImageCreateInfo imageParams =
369 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
370 DE_NULL, // const void* pNext;
371 imageCreateFlags, // VkImageCreateFlags flags;
372 imageType, // VkImageType imageType;
373 format, // VkFormat format;
374 { // VkExtent3D extent;
375 (deUint32)textureDimension.x(),
376 (deUint32)textureDimension.y(),
377 (deUint32)textureDimension.z()
379 mipLevels, // deUint32 mipLevels;
380 arraySize, // deUint32 arrayLayers;
381 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
382 imageTiling, // VkImageTiling tiling;
383 imageUsageFlags, // VkImageUsageFlags usage;
384 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
385 1u, // deUint32 queueFamilyIndexCount;
386 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
387 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
390 m_textureImage = createImage(vkd, vkDevice, &imageParams);
394 pipeline::uploadTestTextureSparse (vkd,
396 m_context.getPhysicalDevice(),
397 m_context.getInstanceInterface(),
408 m_textureImageMemory = allocator.allocate(getImageMemoryRequirements(vkd, vkDevice, *m_textureImage), MemoryRequirement::Any);
409 VK_CHECK(vkd.bindImageMemory(vkDevice, *m_textureImage, m_textureImageMemory->getMemory(), m_textureImageMemory->getOffset()));
411 pipeline::uploadTestTexture (vkd,
420 updateTextureViewMipLevels(0, mipLevels - 1);
423 void TextureBinding::updateTextureViewMipLevels (deUint32 baseLevel, deUint32 maxLevel)
425 const DeviceInterface& vkd = m_context.getDeviceInterface();
426 const VkDevice vkDevice = m_context.getDevice();
427 const vk::VkImageViewType imageViewType = textureTypeToImageViewType(m_type);
428 const vk::VkFormat format = m_textureData->isCompressed() ? mapCompressedTextureFormat(m_textureData->getCompressedLevel(0, 0).getFormat()) : mapTextureFormat(m_textureData->getTextureFormat());
429 const bool isShadowTexture = tcu::hasDepthComponent(m_textureData->getTextureFormat().order);
430 const VkImageAspectFlags aspectMask = isShadowTexture ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
431 const deUint32 layerCount = m_textureData->getArraySize();
432 const vk::VkImageViewCreateInfo viewParams =
434 vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
435 NULL, // const voide* pNext;
436 0u, // VkImageViewCreateFlags flags;
437 *m_textureImage, // VkImage image;
438 imageViewType, // VkImageViewType viewType;
439 format, // VkFormat format;
440 makeComponentMappingRGBA(), // VkComponentMapping components;
442 aspectMask, // VkImageAspectFlags aspectMask;
443 baseLevel, // deUint32 baseMipLevel;
444 maxLevel-baseLevel+1, // deUint32 levelCount;
445 0, // deUint32 baseArrayLayer;
446 layerCount // deUint32 layerCount;
447 }, // VkImageSubresourceRange subresourceRange;
450 m_textureImageView = createImageView(vkd, vkDevice, &viewParams);
453 vk::Allocator* TextureBinding::createAllocator() const
455 VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice());
456 return new SimpleAllocator(m_deviceInterface, *m_device, memoryProperties);
459 Move<VkDevice> TextureBinding::createDevice() const
461 const InstanceInterface& vk = m_context.getInstanceInterface();
462 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
463 const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(vk, physicalDevice);
465 VkDeviceQueueCreateInfo queueInfo;
466 VkDeviceCreateInfo deviceInfo;
467 const float queuePriority = 1.0f;
469 deMemset(&queueInfo, 0, sizeof(queueInfo));
470 deMemset(&deviceInfo, 0, sizeof(deviceInfo));
472 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
473 queueInfo.pNext = DE_NULL;
474 queueInfo.flags = (VkDeviceQueueCreateFlags)0u;
475 queueInfo.queueFamilyIndex = m_queueFamilyIndex;
476 queueInfo.queueCount = 1u;
477 queueInfo.pQueuePriorities = &queuePriority;
479 deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
480 deviceInfo.pNext = DE_NULL;
481 deviceInfo.queueCreateInfoCount = 1u;
482 deviceInfo.pQueueCreateInfos = &queueInfo;
483 deviceInfo.enabledExtensionCount = 0u;
484 deviceInfo.ppEnabledExtensionNames = DE_NULL;
485 deviceInfo.enabledLayerCount = 0u;
486 deviceInfo.ppEnabledLayerNames = DE_NULL;
487 deviceInfo.pEnabledFeatures = &deviceFeatures;
489 return vk::createDevice(vk, physicalDevice, &deviceInfo);
492 const deUint16 TextureRenderer::s_vertexIndices[6] = { 0, 1, 2, 2, 1, 3 };
493 const VkDeviceSize TextureRenderer::s_vertexIndexBufferSize = sizeof(TextureRenderer::s_vertexIndices);
495 TextureRenderer::TextureRenderer (Context& context, VkSampleCountFlagBits sampleCount, deUint32 renderWidth, deUint32 renderHeight)
496 : m_context (context)
497 , m_log (context.getTestContext().getLog())
498 , m_renderWidth (renderWidth)
499 , m_renderHeight (renderHeight)
500 , m_sampleCount (sampleCount)
501 , m_multisampling (m_sampleCount != VK_SAMPLE_COUNT_1_BIT)
502 , m_imageFormat (VK_FORMAT_R8G8B8A8_UNORM)
503 , m_textureFormat (vk::mapVkFormat(m_imageFormat))
504 , m_uniformBufferSize (sizeof(ShaderParameters))
505 , m_resultBufferSize (renderWidth * renderHeight * m_textureFormat.getPixelSize())
506 , m_viewportOffsetX (0.0f)
507 , m_viewportOffsetY (0.0f)
508 , m_viewportWidth ((float)renderWidth)
509 , m_viewportHeight ((float)renderHeight)
511 const DeviceInterface& vkd = m_context.getDeviceInterface();
512 const VkDevice vkDevice = m_context.getDevice();
513 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
514 Allocator& allocator = m_context.getDefaultAllocator();
517 m_commandPool = createCommandPool(vkd, vkDevice, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
521 const VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
522 VkImageFormatProperties properties;
524 if ((m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(),
527 VK_IMAGE_TILING_OPTIMAL,
530 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
532 TCU_THROW(NotSupportedError, "Format not supported");
535 if ((properties.sampleCounts & m_sampleCount) != m_sampleCount)
537 TCU_THROW(NotSupportedError, "Format not supported");
540 const VkImageCreateInfo imageCreateInfo =
542 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
543 DE_NULL, // const void* pNext;
544 0u, // VkImageCreateFlags flags;
545 VK_IMAGE_TYPE_2D, // VkImageType imageType;
546 m_imageFormat, // VkFormat format;
547 { m_renderWidth, m_renderHeight, 1u }, // VkExtent3D extent;
548 1u, // deUint32 mipLevels;
549 1u, // deUint32 arrayLayers;
550 m_sampleCount, // VkSampleCountFlagBits samples;
551 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
552 imageUsage, // VkImageUsageFlags usage;
553 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
554 1u, // deUint32 queueFamilyIndexCount;
555 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
556 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
559 m_image = vk::createImage(vkd, vkDevice, &imageCreateInfo, DE_NULL);
561 m_imageMemory = allocator.allocate(getImageMemoryRequirements(vkd, vkDevice, *m_image), MemoryRequirement::Any);
562 VK_CHECK(vkd.bindImageMemory(vkDevice, *m_image, m_imageMemory->getMemory(), m_imageMemory->getOffset()));
567 const VkImageViewCreateInfo imageViewCreateInfo =
569 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
570 DE_NULL, // const void* pNext;
571 0u, // VkImageViewCreateFlags flags;
572 *m_image, // VkImage image;
573 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
574 m_imageFormat, // VkFormat format;
575 makeComponentMappingRGBA(), // VkComponentMapping components;
577 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
578 0u, // deUint32 baseMipLevel;
579 1u, // deUint32 mipLevels;
580 0u, // deUint32 baseArrayLayer;
581 1u, // deUint32 arraySize;
582 }, // VkImageSubresourceRange subresourceRange;
585 m_imageView = vk::createImageView(vkd, vkDevice, &imageViewCreateInfo, DE_NULL);
592 const VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
593 VkImageFormatProperties properties;
595 if ((m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(),
598 VK_IMAGE_TILING_OPTIMAL,
601 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
603 TCU_THROW(NotSupportedError, "Format not supported");
606 const VkImageCreateInfo imageCreateInfo =
608 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
609 DE_NULL, // const void* pNext;
610 0u, // VkImageCreateFlags flags;
611 VK_IMAGE_TYPE_2D, // VkImageType imageType;
612 m_imageFormat, // VkFormat format;
613 { m_renderWidth, m_renderHeight, 1u }, // VkExtent3D extent;
614 1u, // deUint32 mipLevels;
615 1u, // deUint32 arrayLayers;
616 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
617 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
618 imageUsage, // VkImageUsageFlags usage;
619 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
620 1u, // deUint32 queueFamilyIndexCount;
621 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
622 VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
625 m_resolvedImage = vk::createImage(vkd, vkDevice, &imageCreateInfo, DE_NULL);
626 m_resolvedImageMemory = allocator.allocate(getImageMemoryRequirements(vkd, vkDevice, *m_resolvedImage), MemoryRequirement::Any);
627 VK_CHECK(vkd.bindImageMemory(vkDevice, *m_resolvedImage, m_resolvedImageMemory->getMemory(), m_resolvedImageMemory->getOffset()));
630 // Resolved Image View
632 const VkImageViewCreateInfo imageViewCreateInfo =
634 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
635 DE_NULL, // const void* pNext;
636 0u, // VkImageViewCreateFlags flags;
637 *m_resolvedImage, // VkImage image;
638 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
639 m_imageFormat, // VkFormat format;
640 makeComponentMappingRGBA(), // VkComponentMapping components;
642 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
643 0u, // deUint32 baseMipLevel;
644 1u, // deUint32 mipLevels;
645 0u, // deUint32 baseArrayLayer;
646 1u, // deUint32 arraySize;
647 }, // VkImageSubresourceRange subresourceRange;
650 m_resolvedImageView = vk::createImageView(vkd, vkDevice, &imageViewCreateInfo, DE_NULL);
656 const VkImageLayout imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
657 const VkAttachmentDescription attachmentDesc[] =
660 0u, // VkAttachmentDescriptionFlags flags;
661 m_imageFormat, // VkFormat format;
662 m_sampleCount, // VkSampleCountFlagBits samples;
663 VK_ATTACHMENT_LOAD_OP_LOAD, // VkAttachmentLoadOp loadOp;
664 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
665 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
666 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
667 imageLayout, // VkImageLayout initialLayout;
668 imageLayout, // VkImageLayout finalLayout;
671 0u, // VkAttachmentDescriptionFlags flags;
672 m_imageFormat, // VkFormat format;
673 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
674 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
675 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
676 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
677 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
678 imageLayout, // VkImageLayout initialLayout;
679 imageLayout, // VkImageLayout finalLayout;
683 const VkAttachmentReference attachmentRef =
685 0u, // deUint32 attachment;
686 imageLayout, // VkImageLayout layout;
689 const VkAttachmentReference resolveAttachmentRef =
691 1u, // deUint32 attachment;
692 imageLayout, // VkImageLayout layout;
695 const VkSubpassDescription subpassDesc =
697 0u, // 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 &attachmentRef, // const VkAttachmentReference* pColorAttachments;
703 m_multisampling ? &resolveAttachmentRef : DE_NULL, // const VkAttachmentReference* pResolveAttachments;
704 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
705 0u, // deUint32 preserveAttachmentCount;
706 DE_NULL, // const VkAttachmentReference* pPreserveAttachments;
709 const VkRenderPassCreateInfo renderPassCreateInfo =
711 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
712 DE_NULL, // const void* pNext;
713 0u, // VkRenderPassCreateFlags flags;
714 m_multisampling ? 2u : 1u, // deUint32 attachmentCount;
715 attachmentDesc, // const VkAttachmentDescription* pAttachments;
716 1u, // deUint32 subpassCount;
717 &subpassDesc, // const VkSubpassDescription* pSubpasses;
718 0u, // deUint32 dependencyCount;
719 DE_NULL, // const VkSubpassDependency* pDependencies;
722 m_renderPass = createRenderPass(vkd, vkDevice, &renderPassCreateInfo, DE_NULL);
725 // Vertex index buffer
727 const VkBufferCreateInfo indexBufferParams =
729 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
730 DE_NULL, // const void* pNext;
731 0u, // VkBufferCreateFlags flags;
732 s_vertexIndexBufferSize, // VkDeviceSize size;
733 VK_BUFFER_USAGE_INDEX_BUFFER_BIT, // VkBufferUsageFlags usage;
734 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
735 1u, // deUint32 queueFamilyCount;
736 &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
739 m_vertexIndexBuffer = createBuffer(vkd, vkDevice, &indexBufferParams);
740 m_vertexIndexBufferMemory = allocator.allocate(getBufferMemoryRequirements(vkd, vkDevice, *m_vertexIndexBuffer), MemoryRequirement::HostVisible);
742 VK_CHECK(vkd.bindBufferMemory(vkDevice, *m_vertexIndexBuffer, m_vertexIndexBufferMemory->getMemory(), m_vertexIndexBufferMemory->getOffset()));
744 // Load vertices into vertex buffer
745 deMemcpy(m_vertexIndexBufferMemory->getHostPtr(), s_vertexIndices, s_vertexIndexBufferSize);
746 flushMappedMemoryRange(vkd, vkDevice, m_vertexIndexBufferMemory->getMemory(), m_vertexIndexBufferMemory->getOffset(), VK_WHOLE_SIZE);
751 const VkImageView attachments[] =
754 *m_resolvedImageView,
757 const VkFramebufferCreateInfo framebufferCreateInfo =
759 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
760 DE_NULL, // const void* pNext;
761 0u, // VkFramebufferCreateFlags flags;
762 *m_renderPass, // VkRenderPass renderPass;
763 m_multisampling ? 2u : 1u, // deUint32 attachmentCount;
764 attachments, // const VkImageView* pAttachments;
765 m_renderWidth, // deUint32 width;
766 m_renderHeight, // deUint32 height;
767 1u, // deUint32 layers;
770 m_frameBuffer = createFramebuffer(vkd, vkDevice, &framebufferCreateInfo, DE_NULL);
775 const VkBufferCreateInfo bufferCreateInfo =
777 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
778 DE_NULL, // const void* pNext;
779 0u, // VkBufferCreateFlags flags;
780 m_uniformBufferSize, // VkDeviceSize size;
781 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, // VkBufferUsageFlags usage;
782 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
783 1u, // deUint32 queueFamilyIndexCount;
784 &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
787 m_uniformBuffer = createBuffer(vkd, vkDevice, &bufferCreateInfo);
788 m_uniformBufferMemory = allocator.allocate(getBufferMemoryRequirements(vkd, vkDevice, *m_uniformBuffer), MemoryRequirement::HostVisible);
790 VK_CHECK(vkd.bindBufferMemory(vkDevice, *m_uniformBuffer, m_uniformBufferMemory->getMemory(), m_uniformBufferMemory->getOffset()));
795 DescriptorPoolBuilder descriptorPoolBuilder;
797 descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
798 descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
799 m_descriptorPool = descriptorPoolBuilder.build(vkd, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 2u);
803 m_fence = createFence(vkd, vkDevice);
807 const VkBufferCreateInfo bufferCreateInfo =
809 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
810 DE_NULL, // const void* pNext;
811 0u, // VkBufferCreateFlags flags;
812 m_resultBufferSize, // VkDeviceSize size;
813 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
814 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
815 1u, // deUint32 queueFamilyIndexCount;
816 &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
819 m_resultBuffer = createBuffer(vkd, vkDevice, &bufferCreateInfo);
820 m_resultBufferMemory = allocator.allocate(getBufferMemoryRequirements(vkd, vkDevice, *m_resultBuffer), MemoryRequirement::HostVisible);
822 VK_CHECK(vkd.bindBufferMemory(vkDevice, *m_resultBuffer, m_resultBufferMemory->getMemory(), m_resultBufferMemory->getOffset()));
825 clearImage(*m_image);
827 clearImage(*m_resolvedImage);
830 TextureRenderer::~TextureRenderer (void)
834 void TextureRenderer::clearImage(VkImage image)
836 const DeviceInterface& vkd = m_context.getDeviceInterface();
837 const VkDevice vkDevice = m_context.getDevice();
838 Move<VkCommandBuffer> commandBuffer;
839 const VkQueue queue = m_context.getUniversalQueue();
841 const VkImageSubresourceRange subResourcerange =
843 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
844 0, // deUint32 baseMipLevel;
845 1, // deUint32 levelCount;
846 0, // deUint32 baseArrayLayer;
847 1 // deUint32 layerCount;
850 commandBuffer = allocateCommandBuffer(vkd, vkDevice, *m_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
852 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
854 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
855 DE_NULL, // const void* pNext;
856 0u, // VkCmdBufferOptimizeFlags flags;
857 DE_NULL // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
860 VK_CHECK(vkd.beginCommandBuffer(*commandBuffer, &cmdBufferBeginInfo));
862 addImageTransitionBarrier(*commandBuffer, image,
863 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
864 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
865 0, // VkAccessFlags srcAccessMask
866 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
867 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
868 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); // VkImageLayout newLayout;
870 VkClearColorValue color = makeClearValueColorF32(0.0f, 0.0f, 0.0f, 1.0f).color;
871 vkd.cmdClearColorImage(*commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &subResourcerange);
873 addImageTransitionBarrier(*commandBuffer, image,
874 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // VkPipelineStageFlags srcStageMask
875 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, // VkPipelineStageFlags dstStageMask
876 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask
877 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask
878 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
879 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); // VkImageLayout newLayout;
881 VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
883 const VkSubmitInfo submitInfo =
885 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
886 DE_NULL, // const void* pNext;
887 0u, // deUint32 waitSemaphoreCount;
888 DE_NULL, // const VkSemaphore* pWaitSemaphores;
889 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
890 1u, // deUint32 commandBufferCount;
891 &commandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
892 0u, // deUint32 signalSemaphoreCount;
893 DE_NULL, // const VkSemaphore* pSignalSemaphores;
896 VK_CHECK(vkd.resetFences(vkDevice, 1, &m_fence.get()));
897 VK_CHECK(vkd.queueSubmit(queue, 1, &submitInfo, *m_fence));
898 VK_CHECK(vkd.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
901 void TextureRenderer::add2DTexture (const TestTexture2DSp& texture, TextureBinding::ImageBackingMode backingMode)
903 m_textureBindings.push_back(TextureBindingSp(new TextureBinding(m_context, texture, TextureBinding::TYPE_2D, backingMode)));
906 void TextureRenderer::addCubeTexture (const TestTextureCubeSp& texture, TextureBinding::ImageBackingMode backingMode)
908 m_textureBindings.push_back(TextureBindingSp(new TextureBinding(m_context, texture, TextureBinding::TYPE_CUBE_MAP, backingMode)));
911 void TextureRenderer::add2DArrayTexture (const TestTexture2DArraySp& texture, TextureBinding::ImageBackingMode backingMode)
913 m_textureBindings.push_back(TextureBindingSp(new TextureBinding(m_context, texture, TextureBinding::TYPE_2D_ARRAY, backingMode)));
916 void TextureRenderer::add3DTexture (const TestTexture3DSp& texture, TextureBinding::ImageBackingMode backingMode)
918 m_textureBindings.push_back(TextureBindingSp(new TextureBinding(m_context, texture, TextureBinding::TYPE_3D, backingMode)));
921 const pipeline::TestTexture2D& TextureRenderer::get2DTexture (int textureIndex) const
923 DE_ASSERT(m_textureBindings.size() > (size_t)textureIndex);
924 DE_ASSERT(m_textureBindings[textureIndex]->getType() == TextureBinding::TYPE_2D);
926 return dynamic_cast<const pipeline::TestTexture2D&>(m_textureBindings[textureIndex]->getTestTexture());
929 const pipeline::TestTextureCube& TextureRenderer::getCubeTexture (int textureIndex) const
931 DE_ASSERT(m_textureBindings.size() > (size_t)textureIndex);
932 DE_ASSERT(m_textureBindings[textureIndex]->getType() == TextureBinding::TYPE_CUBE_MAP);
934 return dynamic_cast<const pipeline::TestTextureCube&>(m_textureBindings[textureIndex]->getTestTexture());
937 const pipeline::TestTexture2DArray& TextureRenderer::get2DArrayTexture (int textureIndex) const
939 DE_ASSERT(m_textureBindings.size() > (size_t)textureIndex);
940 DE_ASSERT(m_textureBindings[textureIndex]->getType() == TextureBinding::TYPE_2D_ARRAY);
942 return dynamic_cast<const pipeline::TestTexture2DArray&>(m_textureBindings[textureIndex]->getTestTexture());
945 const pipeline::TestTexture3D& TextureRenderer::get3DTexture (int textureIndex) const
947 DE_ASSERT(m_textureBindings.size() > (size_t)textureIndex);
948 DE_ASSERT(m_textureBindings[textureIndex]->getType() == TextureBinding::TYPE_3D);
950 return dynamic_cast<const pipeline::TestTexture3D&>(m_textureBindings[textureIndex]->getTestTexture());
953 void TextureRenderer::setViewport (float viewportX, float viewportY, float viewportW, float viewportH)
955 m_viewportHeight = viewportH;
956 m_viewportWidth = viewportW;
957 m_viewportOffsetX = viewportX;
958 m_viewportOffsetY = viewportY;
961 TextureBinding* TextureRenderer::getTextureBinding (int textureIndex) const
963 DE_ASSERT(m_textureBindings.size() > (size_t)textureIndex);
964 return m_textureBindings[textureIndex].get();
967 deUint32 TextureRenderer::getRenderWidth (void) const
969 return m_renderWidth;
972 deUint32 TextureRenderer::getRenderHeight (void) const
974 return m_renderHeight;
977 Move<VkDescriptorSet> TextureRenderer::makeDescriptorSet (const VkDescriptorPool descriptorPool, const VkDescriptorSetLayout setLayout) const
979 const DeviceInterface& vkd = m_context.getDeviceInterface();
980 const VkDevice vkDevice = m_context.getDevice();
982 const VkDescriptorSetAllocateInfo allocateParams =
984 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType
985 DE_NULL, // const void* pNext
986 descriptorPool, // VkDescriptorPool descriptorPool
987 1u, // deUint32 descriptorSetCount
988 &setLayout, // const VkDescriptorSetLayout* pSetLayouts
990 return allocateDescriptorSet(vkd, vkDevice, &allocateParams);
993 void TextureRenderer::addImageTransitionBarrier(VkCommandBuffer commandBuffer, VkImage image, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout) const
995 const DeviceInterface& vkd = m_context.getDeviceInterface();
997 const VkImageSubresourceRange subResourcerange =
999 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1000 0, // deUint32 baseMipLevel;
1001 1, // deUint32 levelCount;
1002 0, // deUint32 baseArrayLayer;
1003 1 // deUint32 layerCount;
1006 const VkImageMemoryBarrier imageBarrier =
1008 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1009 DE_NULL, // const void* pNext;
1010 srcAccessMask, // VkAccessFlags srcAccessMask;
1011 dstAccessMask, // VkAccessFlags dstAccessMask;
1012 oldLayout, // VkImageLayout oldLayout;
1013 newLayout, // VkImageLayout newLayout;
1014 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1015 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1016 image, // VkImage image;
1017 subResourcerange // VkImageSubresourceRange subresourceRange;
1020 vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, 0, 0, DE_NULL, 0, DE_NULL, 1, &imageBarrier);
1024 void TextureRenderer::renderQuad (tcu::Surface& result, int texUnit, const float* texCoord, TextureType texType)
1026 renderQuad(result, texUnit, texCoord, ReferenceParams(texType));
1029 void TextureRenderer::renderQuad (tcu::Surface& result, int texUnit, const float* texCoord, const ReferenceParams& params)
1031 const float maxAnisotropy = 1.0f;
1034 -1.0, -1.0f, 0.0f, 1.0f,
1035 -1.0f, +1.0f, 0.0f, 1.0f,
1036 +1.0f, -1.0f, 0.0f, 1.0f,
1037 +1.0f, +1.0f, 0.0f, 1.0f
1039 renderQuad(result, positions, texUnit, texCoord, params, maxAnisotropy);
1042 void TextureRenderer::renderQuad (tcu::Surface& result,
1043 const float* positions,
1045 const float* texCoord,
1046 const glu::TextureTestUtil::ReferenceParams& params,
1047 const float maxAnisotropy)
1049 const DeviceInterface& vkd = m_context.getDeviceInterface();
1050 const VkDevice vkDevice = m_context.getDevice();
1051 const VkQueue queue = m_context.getUniversalQueue();
1052 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
1053 Allocator& allocator = m_context.getDefaultAllocator();
1055 tcu::Vec4 wCoord = params.flags & RenderParams::PROJECTED ? params.w : tcu::Vec4(1.0f);
1056 bool useBias = !!(params.flags & RenderParams::USE_BIAS);
1057 bool logUniforms = !!(params.flags & RenderParams::LOG_UNIFORMS);
1059 // Render quad with texture.
1062 positions[0]*wCoord.x(), positions[1]*wCoord.x(), positions[2], positions[3]*wCoord.x(),
1063 positions[4]*wCoord.y(), positions[5]*wCoord.y(), positions[6], positions[7]*wCoord.y(),
1064 positions[8]*wCoord.z(), positions[9]*wCoord.z(), positions[10], positions[11]*wCoord.z(),
1065 positions[12]*wCoord.w(), positions[13]*wCoord.w(), positions[14], positions[15]*wCoord.w()
1068 Program progSpec = PROGRAM_LAST;
1071 if (params.texType == TEXTURETYPE_2D)
1075 switch (params.samplerType)
1077 case SAMPLERTYPE_FLOAT: progSpec = useBias ? PROGRAM_2D_FLOAT_BIAS : PROGRAM_2D_FLOAT; break;
1078 case SAMPLERTYPE_INT: progSpec = useBias ? PROGRAM_2D_INT_BIAS : PROGRAM_2D_INT; break;
1079 case SAMPLERTYPE_UINT: progSpec = useBias ? PROGRAM_2D_UINT_BIAS : PROGRAM_2D_UINT; break;
1080 case SAMPLERTYPE_SHADOW: progSpec = useBias ? PROGRAM_2D_SHADOW_BIAS : PROGRAM_2D_SHADOW; break;
1081 default: DE_ASSERT(false);
1084 else if (params.texType == TEXTURETYPE_1D)
1088 switch (params.samplerType)
1090 case SAMPLERTYPE_FLOAT: progSpec = useBias ? PROGRAM_1D_FLOAT_BIAS : PROGRAM_1D_FLOAT; break;
1091 case SAMPLERTYPE_INT: progSpec = useBias ? PROGRAM_1D_INT_BIAS : PROGRAM_1D_INT; break;
1092 case SAMPLERTYPE_UINT: progSpec = useBias ? PROGRAM_1D_UINT_BIAS : PROGRAM_1D_UINT; break;
1093 case SAMPLERTYPE_SHADOW: progSpec = useBias ? PROGRAM_1D_SHADOW_BIAS : PROGRAM_1D_SHADOW; break;
1094 default: DE_ASSERT(false);
1097 else if (params.texType == TEXTURETYPE_CUBE)
1101 switch (params.samplerType)
1103 case SAMPLERTYPE_FLOAT: progSpec = useBias ? PROGRAM_CUBE_FLOAT_BIAS : PROGRAM_CUBE_FLOAT; break;
1104 case SAMPLERTYPE_INT: progSpec = useBias ? PROGRAM_CUBE_INT_BIAS : PROGRAM_CUBE_INT; break;
1105 case SAMPLERTYPE_UINT: progSpec = useBias ? PROGRAM_CUBE_UINT_BIAS : PROGRAM_CUBE_UINT; break;
1106 case SAMPLERTYPE_SHADOW: progSpec = useBias ? PROGRAM_CUBE_SHADOW_BIAS : PROGRAM_CUBE_SHADOW; break;
1107 default: DE_ASSERT(false);
1110 else if (params.texType == TEXTURETYPE_3D)
1114 switch (params.samplerType)
1116 case SAMPLERTYPE_FLOAT: progSpec = useBias ? PROGRAM_3D_FLOAT_BIAS : PROGRAM_3D_FLOAT; break;
1117 case SAMPLERTYPE_INT: progSpec = useBias ? PROGRAM_3D_INT_BIAS : PROGRAM_3D_INT; break;
1118 case SAMPLERTYPE_UINT: progSpec = useBias ? PROGRAM_3D_UINT_BIAS : PROGRAM_3D_UINT; break;
1119 default: DE_ASSERT(false);
1122 else if (params.texType == TEXTURETYPE_2D_ARRAY)
1124 DE_ASSERT(!useBias); // \todo [2012-02-17 pyry] Support bias.
1128 switch (params.samplerType)
1130 case SAMPLERTYPE_FLOAT: progSpec = PROGRAM_2D_ARRAY_FLOAT; break;
1131 case SAMPLERTYPE_INT: progSpec = PROGRAM_2D_ARRAY_INT; break;
1132 case SAMPLERTYPE_UINT: progSpec = PROGRAM_2D_ARRAY_UINT; break;
1133 case SAMPLERTYPE_SHADOW: progSpec = PROGRAM_2D_ARRAY_SHADOW; break;
1134 default: DE_ASSERT(false);
1137 else if (params.texType == TEXTURETYPE_CUBE_ARRAY)
1139 DE_ASSERT(!useBias);
1143 switch (params.samplerType)
1145 case SAMPLERTYPE_FLOAT: progSpec = PROGRAM_CUBE_ARRAY_FLOAT; break;
1146 case SAMPLERTYPE_INT: progSpec = PROGRAM_CUBE_ARRAY_INT; break;
1147 case SAMPLERTYPE_UINT: progSpec = PROGRAM_CUBE_ARRAY_UINT; break;
1148 case SAMPLERTYPE_SHADOW: progSpec = PROGRAM_CUBE_ARRAY_SHADOW; break;
1149 default: DE_ASSERT(false);
1152 else if (params.texType == TEXTURETYPE_1D_ARRAY)
1154 DE_ASSERT(!useBias); // \todo [2012-02-17 pyry] Support bias.
1158 switch (params.samplerType)
1160 case SAMPLERTYPE_FLOAT: progSpec = PROGRAM_1D_ARRAY_FLOAT; break;
1161 case SAMPLERTYPE_INT: progSpec = PROGRAM_1D_ARRAY_INT; break;
1162 case SAMPLERTYPE_UINT: progSpec = PROGRAM_1D_ARRAY_UINT; break;
1163 case SAMPLERTYPE_SHADOW: progSpec = PROGRAM_1D_ARRAY_SHADOW; break;
1164 default: DE_ASSERT(false);
1167 else if (params.texType == TEXTURETYPE_BUFFER)
1171 switch (params.samplerType)
1173 case SAMPLERTYPE_FETCH_FLOAT: progSpec = PROGRAM_BUFFER_FLOAT; break;
1174 case SAMPLERTYPE_FETCH_INT: progSpec = PROGRAM_BUFFER_INT; break;
1175 case SAMPLERTYPE_FETCH_UINT: progSpec = PROGRAM_BUFFER_UINT; break;
1176 default: DE_ASSERT(false);
1180 DE_ASSERT(DE_FALSE);
1182 Unique<VkShaderModule> vertexShaderModule (createShaderModule(vkd, vkDevice, m_context.getBinaryCollection().get("vertext_" + std::string(getProgramName(progSpec))), 0));
1183 Unique<VkShaderModule> fragmentShaderModule (createShaderModule(vkd, vkDevice, m_context.getBinaryCollection().get("fragment_" + std::string(getProgramName(progSpec))), 0));
1185 Move<VkSampler> sampler;
1186 Move<VkDescriptorSet> descriptorSet[2];
1187 Move<VkDescriptorSetLayout> descriptorSetLayout[2];
1188 Move<VkPipelineLayout> pipelineLayout;
1190 Move<VkCommandBuffer> commandBuffer;
1191 Move<VkPipeline> graphicsPipeline;
1192 Move<VkBuffer> vertexBuffer;
1193 de::MovePtr<Allocation> vertexBufferMemory;
1194 const deUint32 positionDataSize = deUint32(sizeof(float) * 4 * 4);
1195 const deUint32 textureCoordDataSize = deUint32(sizeof(float) * numComps * 4);
1197 const VkPhysicalDeviceProperties properties = m_context.getDeviceProperties();
1199 if (positionDataSize > properties.limits.maxVertexInputAttributeOffset)
1201 std::stringstream message;
1202 message << "Larger vertex input attribute offset is needed (" << positionDataSize << ") than the available maximum (" << properties.limits.maxVertexInputAttributeOffset << ").";
1203 TCU_THROW(NotSupportedError, message.str().c_str());
1206 // Create Graphics Pipeline
1208 const VkPipelineShaderStageCreateInfo shaderStageParams[2] =
1211 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1212 DE_NULL, // const void* pNext;
1213 0, // VkPipelineShaderStageCreateFlags flags;
1214 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStage stage;
1215 *vertexShaderModule, // VkShaderModule shader;
1216 "main", // const char* pName;
1217 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
1220 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1221 DE_NULL, // const void* pNext;
1222 0, // VkPipelineShaderStageCreateFlags flags;
1223 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStage stage;
1224 *fragmentShaderModule, // VkShaderModule shader;
1225 "main", // const char* pName;
1226 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
1230 const deUint32 vertexPositionStrideSize = deUint32(sizeof(tcu::Vec4));
1231 const deUint32 vertexTextureStrideSize = deUint32(numComps * sizeof(float));
1233 const VkVertexInputBindingDescription vertexInputBindingDescription[2] =
1236 0u, // deUint32 binding;
1237 vertexPositionStrideSize, // deUint32 strideInBytes;
1238 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputStepRate stepRate;
1241 1u, // deUint32 binding;
1242 vertexTextureStrideSize, // deUint32 strideInBytes;
1243 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputStepRate stepRate;
1247 VkFormat textureCoordinateFormat = VK_FORMAT_R32G32B32A32_SFLOAT;
1250 case 1: textureCoordinateFormat = VK_FORMAT_R32_SFLOAT; break;
1251 case 2: textureCoordinateFormat = VK_FORMAT_R32G32_SFLOAT; break;
1252 case 3: textureCoordinateFormat = VK_FORMAT_R32G32B32_SFLOAT; break;
1253 case 4: textureCoordinateFormat = VK_FORMAT_R32G32B32A32_SFLOAT; break;
1258 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
1261 0u, // deUint32 location;
1262 0u, // deUint32 binding;
1263 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
1264 0u // deUint32 offsetInBytes;
1267 1u, // deUint32 location;
1268 1u, // deUint32 binding;
1269 textureCoordinateFormat, // VkFormat format;
1270 positionDataSize // deUint32 offsetInBytes;
1274 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
1276 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
1277 DE_NULL, // const void* pNext;
1278 0, // VkPipelineVertexInputStateCreateFlags flags;
1279 2u, // deUint32 bindingCount;
1280 vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
1281 2u, // deUint32 attributeCount;
1282 vertexInputAttributeDescriptions // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
1285 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
1287 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
1288 DE_NULL, // const void* pNext;
1289 0, // VkPipelineInputAssemblyStateCreateFlags flags;
1290 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
1291 VK_FALSE // VkBool32 primitiveRestartEnable;
1294 const VkViewport viewport =
1296 m_viewportOffsetX, // float originX;
1297 m_viewportOffsetY, // float originY;
1298 m_viewportWidth, // float width;
1299 m_viewportHeight, // float height;
1300 0.0f, // float minDepth;
1301 1.0f // float maxDepth;
1304 const VkRect2D scissor =
1306 { 0, 0 }, // VkOffset2D offset;
1307 { m_renderWidth, m_renderHeight } // VkExtent2D extent;
1310 const VkPipelineViewportStateCreateInfo viewportStateParams =
1312 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
1313 DE_NULL, // const void* pNext;
1314 0, // VkPipelineViewportStateCreateFlags flags;
1315 1u, // deUint32 viewportCount;
1316 &viewport, // const VkViewport* pViewports;
1317 1u, // deUint32 scissorCount;
1318 &scissor // const VkRect2D* pScissors;
1321 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
1323 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
1324 DE_NULL, // const void* pNext;
1325 0u, // VkPipelineMultisampleStateCreateFlags flags;
1326 m_sampleCount, // VkSampleCountFlagBits rasterizationSamples;
1327 VK_FALSE, // VkBool32 sampleShadingEnable;
1328 0.0f, // float minSampleShading;
1329 DE_NULL, // const VkSampleMask* pSampleMask;
1330 VK_FALSE, // VkBool32 alphaToCoverageEnable;
1331 VK_FALSE // VkBool32 alphaToOneEnable;
1334 const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
1336 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
1337 DE_NULL, // const void* pNext;
1338 0, // VkPipelineRasterizationStateCreateFlags flags;
1339 VK_FALSE, // VkBool32 depthClipEnable;
1340 VK_FALSE, // VkBool32 rasterizerDiscardEnable;
1341 VK_POLYGON_MODE_FILL, // VkFillMode fillMode;
1342 VK_CULL_MODE_NONE, // VkCullMode cullMode;
1343 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
1344 VK_FALSE, // VkBool32 depthBiasEnable;
1345 0.0f, // float depthBias;
1346 0.0f, // float depthBiasClamp;
1347 0.0f, // float slopeScaledDepthBias;
1348 1.0f, // float lineWidth;
1351 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
1353 VK_FALSE, // VkBool32 blendEnable;
1354 VK_BLEND_FACTOR_ONE, // VkBlend srcBlendColor;
1355 VK_BLEND_FACTOR_ZERO, // VkBlend destBlendColor;
1356 VK_BLEND_OP_ADD, // VkBlendOp blendOpColor;
1357 VK_BLEND_FACTOR_ONE, // VkBlend srcBlendAlpha;
1358 VK_BLEND_FACTOR_ZERO, // VkBlend destBlendAlpha;
1359 VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha;
1360 (VK_COLOR_COMPONENT_R_BIT |
1361 VK_COLOR_COMPONENT_G_BIT |
1362 VK_COLOR_COMPONENT_B_BIT |
1363 VK_COLOR_COMPONENT_A_BIT) // VkChannelFlags channelWriteMask;
1366 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
1368 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
1369 DE_NULL, // const void* pNext;
1370 0, // VkPipelineColorBlendStateCreateFlags flags;
1371 VK_FALSE, // VkBool32 logicOpEnable;
1372 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
1373 1u, // deUint32 attachmentCount;
1374 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
1375 { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConst[4];
1378 VkSamplerCreateInfo samplerCreateInfo = mapSampler(params.sampler, m_textureBindings[texUnit]->getTestTexture().getTextureFormat(), params.minLod, params.maxLod);
1380 if (maxAnisotropy > 1.0f)
1382 samplerCreateInfo.anisotropyEnable = VK_TRUE;
1383 samplerCreateInfo.maxAnisotropy = maxAnisotropy;
1386 if (samplerCreateInfo.magFilter == VK_FILTER_LINEAR || samplerCreateInfo.minFilter == VK_FILTER_LINEAR || samplerCreateInfo.mipmapMode == VK_SAMPLER_MIPMAP_MODE_LINEAR)
1388 const pipeline::TestTexture& testTexture = m_textureBindings[texUnit]->getTestTexture();
1389 const VkFormat textureFormat = testTexture.isCompressed() ? mapCompressedTextureFormat(testTexture.getCompressedLevel(0, 0).getFormat())
1390 : mapTextureFormat (testTexture.getTextureFormat());
1391 const VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice(), textureFormat);
1393 if (!(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1394 TCU_THROW(NotSupportedError, "Linear filtering for this image format is not supported");
1397 sampler = createSampler(vkd, vkDevice, &samplerCreateInfo);
1399 descriptorSetLayout[0] = DescriptorSetLayoutBuilder()
1400 .addSingleBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT)
1401 .build(vkd, vkDevice);
1403 descriptorSetLayout[1] = DescriptorSetLayoutBuilder()
1404 .addSingleSamplerBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, &sampler.get())
1405 .build(vkd, vkDevice);
1408 descriptorSet[0] = makeDescriptorSet(*m_descriptorPool, *descriptorSetLayout[0]);
1409 descriptorSet[1] = makeDescriptorSet(*m_descriptorPool, *descriptorSetLayout[1]);
1412 const VkDescriptorBufferInfo descriptorBufferInfo =
1414 *m_uniformBuffer, // VkBuffer buffer;
1415 0u, // VkDeviceSize offset;
1416 VK_WHOLE_SIZE // VkDeviceSize range;
1419 DescriptorSetUpdateBuilder()
1420 .writeSingle(*descriptorSet[0], DescriptorSetUpdateBuilder::Location::binding(0), VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descriptorBufferInfo)
1421 .update(vkd, vkDevice);
1425 VkDescriptorImageInfo descriptorImageInfo =
1427 *sampler, // VkSampler sampler;
1428 m_textureBindings[texUnit]->getImageView(), // VkImageView imageView;
1429 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL // VkImageLayout imageLayout;
1432 DescriptorSetUpdateBuilder()
1433 .writeSingle(*descriptorSet[1], DescriptorSetUpdateBuilder::Location::binding(0), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorImageInfo)
1434 .update(vkd, vkDevice);
1439 VkDescriptorSetLayout descriptorSetLayouts[2] =
1441 *descriptorSetLayout[0],
1442 *descriptorSetLayout[1]
1445 const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1447 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
1448 DE_NULL, // const void* pNext;
1449 0u, // VkPipelineLayoutCreateFlags flags;
1450 2u, // deUint32 descriptorSetCount;
1451 descriptorSetLayouts, // const VkDescriptorSetLayout* pSetLayouts;
1452 0u, // deUint32 pushConstantRangeCount;
1453 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
1456 pipelineLayout = createPipelineLayout(vkd, vkDevice, &pipelineLayoutCreateInfo);
1459 const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
1461 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
1462 DE_NULL, // const void* pNext;
1463 0u, // VkPipelineCreateFlags flags;
1464 2u, // deUint32 stageCount;
1465 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
1466 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
1467 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
1468 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
1469 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
1470 &rasterizationStateCreateInfo, // const VkPipelineRasterStateCreateInfo* pRasterizationState;
1471 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
1472 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
1473 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
1474 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
1475 *pipelineLayout, // VkPipelineLayout layout;
1476 *m_renderPass, // VkRenderPass renderPass;
1477 0u, // deUint32 subpass;
1478 0u, // VkPipeline basePipelineHandle;
1479 0u // deInt32 basePipelineIndex;
1482 graphicsPipeline = createGraphicsPipeline(vkd, vkDevice, DE_NULL, &graphicsPipelineParams);
1485 // Create Vertex Buffer
1487 const VkBufferCreateInfo vertexBufferParams =
1489 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1490 DE_NULL, // const void* pNext;
1491 0u, // VkBufferCreateFlags flags;
1492 positionDataSize + textureCoordDataSize, // VkDeviceSize size;
1493 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage;
1494 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1495 1u, // deUint32 queueFamilyCount;
1496 &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
1499 vertexBuffer = createBuffer(vkd, vkDevice, &vertexBufferParams);
1500 vertexBufferMemory = allocator.allocate(getBufferMemoryRequirements(vkd, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
1502 VK_CHECK(vkd.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset()));
1504 // Load vertices into vertex buffer
1505 deMemcpy(vertexBufferMemory->getHostPtr(), position, positionDataSize);
1506 deMemcpy(reinterpret_cast<deUint8*>(vertexBufferMemory->getHostPtr()) + positionDataSize, texCoord, textureCoordDataSize);
1507 flushMappedMemoryRange(vkd, vkDevice, vertexBufferMemory->getMemory(), vertexBufferMemory->getOffset(), VK_WHOLE_SIZE);
1510 // Create Command Buffer
1511 commandBuffer = allocateCommandBuffer(vkd, vkDevice, *m_commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
1513 // Begin Command Buffer
1515 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1517 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1518 DE_NULL, // const void* pNext;
1519 0u, // VkCmdBufferOptimizeFlags flags;
1520 DE_NULL // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
1523 VK_CHECK(vkd.beginCommandBuffer(*commandBuffer, &cmdBufferBeginInfo));
1526 // Begin Render Pass
1528 const VkRenderPassBeginInfo renderPassBeginInfo =
1530 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
1531 DE_NULL, // const void* pNext;
1532 *m_renderPass, // VkRenderPass renderPass;
1533 *m_frameBuffer, // VkFramebuffer framebuffer;
1536 { m_renderWidth, m_renderHeight }
1537 }, // VkRect2D renderArea;
1538 0u, // deUint32 clearValueCount;
1539 DE_NULL // const VkClearValue* pClearValues;
1542 vkd.cmdBeginRenderPass(*commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
1545 const VkDeviceSize vertexBufferOffset = 0;
1547 vkd.cmdBindPipeline(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
1548 vkd.cmdBindDescriptorSets(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1, &descriptorSet[0].get(), 0u, DE_NULL);
1549 vkd.cmdBindDescriptorSets(*commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 1u, 1, &descriptorSet[1].get(), 0u, DE_NULL);
1550 vkd.cmdBindVertexBuffers(*commandBuffer, 0, 1, &vertexBuffer.get(), &vertexBufferOffset);
1551 vkd.cmdBindVertexBuffers(*commandBuffer, 1, 1, &vertexBuffer.get(), &vertexBufferOffset);
1552 vkd.cmdBindIndexBuffer(*commandBuffer, *m_vertexIndexBuffer, 0, VK_INDEX_TYPE_UINT16);
1553 vkd.cmdDrawIndexed(*commandBuffer, 6, 1, 0, 0, 0);
1554 vkd.cmdEndRenderPass(*commandBuffer);
1558 const VkBufferMemoryBarrier bufferBarrier =
1560 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1561 DE_NULL, // const void* pNext;
1562 VK_ACCESS_TRANSFER_WRITE_BIT, // VkMemoryOutputFlags outputMask;
1563 VK_ACCESS_HOST_READ_BIT, // VkMemoryInputFlags inputMask;
1564 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1565 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1566 *m_resultBuffer, // VkBuffer buffer;
1567 0u, // VkDeviceSize offset;
1568 m_resultBufferSize // VkDeviceSize size;
1571 const VkBufferImageCopy copyRegion =
1573 0u, // VkDeviceSize bufferOffset;
1574 m_renderWidth, // deUint32 bufferRowLength;
1575 m_renderHeight, // deUint32 bufferImageHeight;
1577 VK_IMAGE_ASPECT_COLOR_BIT,
1581 }, // VkImageSubresourceCopy imageSubresource;
1582 { 0, 0, 0 }, // VkOffset3D imageOffset;
1583 { m_renderWidth, m_renderHeight, 1u } // VkExtent3D imageExtent;
1586 addImageTransitionBarrier(*commandBuffer,
1587 m_multisampling ? *m_resolvedImage : *m_image,
1588 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags srcStageMask
1589 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask
1590 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask
1591 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask
1592 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
1593 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); // VkImageLayout newLayout;
1595 if (m_multisampling)
1596 vkd.cmdCopyImageToBuffer(*commandBuffer, *m_resolvedImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *m_resultBuffer, 1, ©Region);
1598 vkd.cmdCopyImageToBuffer(*commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *m_resultBuffer, 1, ©Region);
1600 vkd.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1602 addImageTransitionBarrier(*commandBuffer,
1603 m_multisampling ? *m_resolvedImage : *m_image,
1604 VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags srcStageMask
1605 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags dstStageMask
1606 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags srcAccessMask
1607 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask
1608 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout oldLayout;
1609 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); // VkImageLayout newLayout;
1612 VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
1614 // Upload uniform buffer data
1616 const ShaderParameters shaderParameters =
1618 params.bias, // float bias; //!< User-supplied bias.
1619 params.ref, // float ref; //!< Reference value for shadow lookups.
1620 tcu::Vec2(), // tcu::Vec2 padding; //!< Shader uniform padding.
1621 params.colorScale, // tcu::Vec4 colorScale; //!< Scale for texture color values.
1622 params.colorBias // tcu::Vec4 colorBias; //!< Bias for texture color values.
1624 deMemcpy(m_uniformBufferMemory->getHostPtr(), &shaderParameters, sizeof(shaderParameters));
1625 flushMappedMemoryRange(vkd, vkDevice, m_uniformBufferMemory->getMemory(), m_uniformBufferMemory->getOffset(), VK_WHOLE_SIZE);
1628 m_log << TestLog::Message << "u_sampler = " << texUnit << TestLog::EndMessage;
1633 m_log << TestLog::Message << "u_bias = " << shaderParameters.bias << TestLog::EndMessage;
1636 if (params.samplerType == SAMPLERTYPE_SHADOW)
1639 m_log << TestLog::Message << "u_ref = " << shaderParameters.ref << TestLog::EndMessage;
1644 m_log << TestLog::Message << "u_colorScale = " << shaderParameters.colorScale << TestLog::EndMessage;
1645 m_log << TestLog::Message << "u_colorBias = " << shaderParameters.colorBias << TestLog::EndMessage;
1651 const VkSubmitInfo submitInfo =
1653 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
1654 DE_NULL, // const void* pNext;
1655 0u, // deUint32 waitSemaphoreCount;
1656 DE_NULL, // const VkSemaphore* pWaitSemaphores;
1657 DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
1658 1u, // deUint32 commandBufferCount;
1659 &commandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
1660 0u, // deUint32 signalSemaphoreCount;
1661 DE_NULL, // const VkSemaphore* pSignalSemaphores;
1664 VK_CHECK(vkd.resetFences(vkDevice, 1, &m_fence.get()));
1665 VK_CHECK(vkd.queueSubmit(queue, 1, &submitInfo, *m_fence));
1666 VK_CHECK(vkd.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
1669 invalidateMappedMemoryRange(vkd, vkDevice, m_resultBufferMemory->getMemory(), m_resultBufferMemory->getOffset(), VK_WHOLE_SIZE);
1671 tcu::copy(result.getAccess(), tcu::ConstPixelBufferAccess(m_textureFormat, tcu::IVec3(m_renderWidth, m_renderHeight, 1u), m_resultBufferMemory->getHostPtr()));
1674 /*--------------------------------------------------------------------*//*!
1675 * \brief Map Vulkan sampler parameters to tcu::Sampler.
1677 * If no mapping is found, throws tcu::InternalError.
1679 * \param wrapU U-component wrap mode
1680 * \param wrapV V-component wrap mode
1681 * \param wrapW W-component wrap mode
1682 * \param minFilterMode Minification filter mode
1683 * \param magFilterMode Magnification filter mode
1684 * \return Sampler description.
1685 *//*--------------------------------------------------------------------*/
1686 tcu::Sampler createSampler (tcu::Sampler::WrapMode wrapU, tcu::Sampler::WrapMode wrapV, tcu::Sampler::WrapMode wrapW, tcu::Sampler::FilterMode minFilterMode, tcu::Sampler::FilterMode magFilterMode)
1688 return tcu::Sampler(wrapU, wrapV, wrapW,
1689 minFilterMode, magFilterMode,
1690 0.0f /* lod threshold */,
1691 true /* normalized coords */,
1692 tcu::Sampler::COMPAREMODE_NONE /* no compare */,
1693 0 /* compare channel */,
1694 tcu::Vec4(0.0f) /* border color, not used */);
1697 /*--------------------------------------------------------------------*//*!
1698 * \brief Map Vulkan sampler parameters to tcu::Sampler.
1700 * If no mapping is found, throws tcu::InternalError.
1702 * \param wrapU U-component wrap mode
1703 * \param wrapV V-component wrap mode
1704 * \param minFilterMode Minification filter mode
1705 * \param minFilterMode Magnification filter mode
1706 * \return Sampler description.
1707 *//*--------------------------------------------------------------------*/
1708 tcu::Sampler createSampler (tcu::Sampler::WrapMode wrapU, tcu::Sampler::WrapMode wrapV, tcu::Sampler::FilterMode minFilterMode, tcu::Sampler::FilterMode magFilterMode)
1710 return createSampler(wrapU, wrapV, wrapU, minFilterMode, magFilterMode);
1713 /*--------------------------------------------------------------------*//*!
1714 * \brief Map Vulkan sampler parameters to tcu::Sampler.
1716 * If no mapping is found, throws tcu::InternalError.
1718 * \param wrapU U-component wrap mode
1719 * \param minFilterMode Minification filter mode
1720 * \return Sampler description.
1721 *//*--------------------------------------------------------------------*/
1722 tcu::Sampler createSampler (tcu::Sampler::WrapMode wrapU, tcu::Sampler::FilterMode minFilterMode, tcu::Sampler::FilterMode magFilterMode)
1724 return createSampler(wrapU, wrapU, wrapU, minFilterMode, magFilterMode);
1727 TestTexture2DSp loadTexture2D (const tcu::Archive& archive, const std::vector<std::string>& filenames)
1729 DE_ASSERT(filenames.size() > 0);
1731 TestTexture2DSp texture;
1733 std::string ext = de::FilePath(filenames[0]).getFileExtension();
1738 for (size_t fileIndex = 0; fileIndex < filenames.size(); ++fileIndex)
1740 tcu::TextureLevel level;
1742 tcu::ImageIO::loadImage(level, archive, filenames[fileIndex].c_str());
1744 TCU_CHECK_INTERNAL(level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8) ||
1745 level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8));
1748 texture = TestTexture2DSp(new pipeline::TestTexture2D(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), level.getWidth(), level.getHeight()));
1750 tcu::copy(texture->getLevel((int)fileIndex, 0), level.getAccess());
1753 else if (ext == "pkm")
1756 for (size_t fileIndex = 0; fileIndex < filenames.size(); ++fileIndex)
1758 // Compressed texture.
1759 tcu::CompressedTexture level;
1761 tcu::ImageIO::loadPKM(level, archive, filenames[fileIndex].c_str());
1763 tcu::TextureFormat uncompressedFormat = tcu::getUncompressedFormat(level.getFormat());
1764 std::vector<deUint8> uncompressedData (uncompressedFormat.getPixelSize() * level.getWidth() * level.getHeight(), 0);
1765 tcu::PixelBufferAccess decompressedBuffer (uncompressedFormat, level.getWidth(), level.getHeight(), 1, uncompressedData.data());
1767 tcu::TextureFormat commonFormat = tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8);
1768 std::vector<deUint8> commonFromatData (commonFormat.getPixelSize() * level.getWidth() * level.getHeight(), 0);
1769 tcu::PixelBufferAccess commonFormatBuffer (commonFormat, level.getWidth(), level.getHeight(), 1, commonFromatData.data());
1772 texture = TestTexture2DSp(new pipeline::TestTexture2D(commonFormat, level.getWidth(), level.getHeight()));
1774 level.decompress(decompressedBuffer, tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_LDR));
1776 tcu::copy(commonFormatBuffer, decompressedBuffer);
1777 tcu::copy(texture->getLevel((int)fileIndex, 0), commonFormatBuffer);
1781 TCU_FAIL("Unsupported file format");
1786 TestTextureCubeSp loadTextureCube (const tcu::Archive& archive, const std::vector<std::string>& filenames)
1788 DE_ASSERT(filenames.size() > 0);
1789 DE_STATIC_ASSERT(tcu::CUBEFACE_LAST == 6);
1790 TCU_CHECK((int)filenames.size() % tcu::CUBEFACE_LAST == 0);
1792 TestTextureCubeSp texture;
1794 std::string ext = de::FilePath(filenames[0]).getFileExtension();
1799 for (size_t fileIndex = 0; fileIndex < filenames.size(); ++fileIndex)
1801 tcu::TextureLevel level;
1803 tcu::ImageIO::loadImage(level, archive, filenames[fileIndex].c_str());
1805 TCU_CHECK_INTERNAL(level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8) ||
1806 level.getFormat() == tcu::TextureFormat(tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8));
1808 TCU_CHECK( level.getWidth() == level.getHeight());
1811 texture = TestTextureCubeSp(new pipeline::TestTextureCube(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), level.getWidth()));
1813 tcu::copy(texture->getLevel((int)fileIndex / 6, (int)fileIndex % 6), level.getAccess());
1816 else if (ext == "pkm")
1818 for (size_t fileIndex = 0; fileIndex < filenames.size(); ++fileIndex)
1820 // Compressed texture.
1821 tcu::CompressedTexture level;
1823 tcu::ImageIO::loadPKM(level, archive, filenames[fileIndex].c_str());
1825 TCU_CHECK( level.getWidth() == level.getHeight());
1827 tcu::TextureFormat uncompressedFormat = tcu::getUncompressedFormat(level.getFormat());
1828 std::vector<deUint8> uncompressedData (uncompressedFormat.getPixelSize() * level.getWidth() * level.getHeight(), 0);
1829 tcu::PixelBufferAccess decompressedBuffer (uncompressedFormat, level.getWidth(), level.getHeight(), 1, uncompressedData.data());
1831 tcu::TextureFormat commonFormat = tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8);
1832 std::vector<deUint8> commonFromatData (commonFormat.getPixelSize() * level.getWidth() * level.getHeight(), 0);
1833 tcu::PixelBufferAccess commonFormatBuffer (commonFormat, level.getWidth(), level.getHeight(), 1, commonFromatData.data());
1836 texture = TestTextureCubeSp(new pipeline::TestTextureCube(commonFormat, level.getWidth()));
1838 level.decompress(decompressedBuffer, tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_LDR));
1840 tcu::copy(commonFormatBuffer, decompressedBuffer);
1841 tcu::copy(texture->getLevel((int)fileIndex / 6, (int)fileIndex % 6), commonFormatBuffer);
1845 TCU_FAIL("Unsupported file format");
1850 TextureCommonTestCaseParameters::TextureCommonTestCaseParameters (void)
1851 : sampleCount (VK_SAMPLE_COUNT_1_BIT)
1852 , texCoordPrecision (glu::PRECISION_HIGHP)
1853 , minFilter (tcu::Sampler::LINEAR)
1854 , magFilter (tcu::Sampler::LINEAR)
1855 , wrapS (tcu::Sampler::REPEAT_GL)
1856 , wrapT (tcu::Sampler::REPEAT_GL)
1857 , format (VK_FORMAT_R8G8B8A8_UNORM)
1861 Texture2DTestCaseParameters::Texture2DTestCaseParameters (void)
1867 TextureCubeTestCaseParameters::TextureCubeTestCaseParameters (void)
1872 Texture2DArrayTestCaseParameters::Texture2DArrayTestCaseParameters (void)
1877 Texture3DTestCaseParameters::Texture3DTestCaseParameters (void)
1878 : wrapR (tcu::Sampler::REPEAT_GL)