1 #ifndef _VKTTEXTURETESTUTIL_HPP
2 #define _VKTTEXTURETESTUTIL_HPP
3 /*------------------------------------------------------------------------
4 * Vulkan Conformance Tests
5 * ------------------------
6 *
7 * Copyright (c) 2016 The Khronos Group Inc.
8 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
9 * Copyright (c) 2014 The Android Open Source Project
10 *
11 * Licensed under the Apache License, Version 2.0 (the "License");
12 * you may not use this file except in compliance with the License.
13 * You may obtain a copy of the License at
14 *
15 * http://www.apache.org/licenses/LICENSE-2.0
16 *
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
22 *
23 *//*!
24 * \file
25 * \brief Texture test utilities.
26 *
27 * About coordinates:
28 * + Quads consist of 2 triangles, rendered using explicit indices.
29 * + All TextureTestUtil functions and classes expect texture coordinates
30 * for quads to be specified in order (-1, -1), (-1, 1), (1, -1), (1, 1).
31 *//*--------------------------------------------------------------------*/
32
33 #include "tcuDefs.hpp"
34 #include "tcuSurface.hpp"
35
36 #include "vkDefs.hpp"
37 #include "vkTypeUtil.hpp"
38 #include "vktTestCase.hpp"
39
40 #include "gluShaderProgram.hpp"
41 #include "gluTextureTestUtil.hpp"
42 #include "deSharedPtr.hpp"
43
44 #include "../pipeline/vktPipelineImageUtil.hpp"
45
46 namespace vkt
47 {
48
49 namespace texture
50 {
51
52 namespace util
53 {
54
55 enum Program
56 {
57 PROGRAM_2D_FLOAT = 0,
58 PROGRAM_2D_INT,
59 PROGRAM_2D_UINT,
60 PROGRAM_2D_FETCH_LOD,
61 PROGRAM_2D_SHADOW,
62
63 PROGRAM_2D_FLOAT_BIAS,
64 PROGRAM_2D_INT_BIAS,
65 PROGRAM_2D_UINT_BIAS,
66 PROGRAM_2D_SHADOW_BIAS,
67
68 PROGRAM_1D_FLOAT,
69 PROGRAM_1D_INT,
70 PROGRAM_1D_UINT,
71 PROGRAM_1D_SHADOW,
72
73 PROGRAM_1D_FLOAT_BIAS,
74 PROGRAM_1D_INT_BIAS,
75 PROGRAM_1D_UINT_BIAS,
76 PROGRAM_1D_SHADOW_BIAS,
77
78 PROGRAM_CUBE_FLOAT,
79 PROGRAM_CUBE_INT,
80 PROGRAM_CUBE_UINT,
81 PROGRAM_CUBE_SHADOW,
82
83 PROGRAM_CUBE_FLOAT_BIAS,
84 PROGRAM_CUBE_INT_BIAS,
85 PROGRAM_CUBE_UINT_BIAS,
86 PROGRAM_CUBE_SHADOW_BIAS,
87
88 PROGRAM_1D_ARRAY_FLOAT,
89 PROGRAM_1D_ARRAY_INT,
90 PROGRAM_1D_ARRAY_UINT,
91 PROGRAM_1D_ARRAY_SHADOW,
92
93 PROGRAM_2D_ARRAY_FLOAT,
94 PROGRAM_2D_ARRAY_INT,
95 PROGRAM_2D_ARRAY_UINT,
96 PROGRAM_2D_ARRAY_SHADOW,
97
98 PROGRAM_3D_FLOAT,
99 PROGRAM_3D_INT,
100 PROGRAM_3D_UINT,
101 PROGRAM_3D_FETCH_LOD,
102
103 PROGRAM_3D_FLOAT_BIAS,
104 PROGRAM_3D_INT_BIAS,
105 PROGRAM_3D_UINT_BIAS,
106
107 PROGRAM_CUBE_ARRAY_FLOAT,
108 PROGRAM_CUBE_ARRAY_INT,
109 PROGRAM_CUBE_ARRAY_UINT,
110 PROGRAM_CUBE_ARRAY_SHADOW,
111
112 PROGRAM_BUFFER_FLOAT,
113 PROGRAM_BUFFER_INT,
114 PROGRAM_BUFFER_UINT,
115
116 PROGRAM_LAST
117 };
118
119 void initializePrograms(vk::SourceCollections &programCollection, glu::Precision texCoordPrecision,
120 const std::vector<Program> &programs, const char *texCoordSwizzle = DE_NULL,
121 glu::Precision fragOutputPrecision = glu::Precision::PRECISION_MEDIUMP, bool unnormal = false);
122
123 typedef de::SharedPtr<pipeline::TestTexture> TestTextureSp;
124 typedef de::SharedPtr<pipeline::TestTexture2D> TestTexture2DSp;
125 typedef de::SharedPtr<pipeline::TestTextureCube> TestTextureCubeSp;
126 typedef de::SharedPtr<pipeline::TestTexture2DArray> TestTexture2DArraySp;
127 typedef de::SharedPtr<pipeline::TestTexture3D> TestTexture3DSp;
128 typedef de::SharedPtr<pipeline::TestTexture1D> TestTexture1DSp;
129 typedef de::SharedPtr<pipeline::TestTexture1DArray> TestTexture1DArraySp;
130 typedef de::SharedPtr<pipeline::TestTextureCubeArray> TestTextureCubeArraySp;
131
132 class TextureBinding
133 {
134 public:
135 enum Type
136 {
137 TYPE_NONE = 0,
138 TYPE_2D,
139 TYPE_CUBE_MAP,
140 TYPE_2D_ARRAY,
141 TYPE_3D,
142
143 TYPE_1D,
144 TYPE_1D_ARRAY,
145 TYPE_CUBE_ARRAY,
146
147 TYPE_LAST
148 };
149
150 enum ImageBackingMode
151 {
152 IMAGE_BACKING_MODE_REGULAR = 0,
153 IMAGE_BACKING_MODE_SPARSE,
154
155 IMAGE_BACKING_MODE_LAST
156 };
157 TextureBinding(Context &context);
158 TextureBinding(Context &context, vk::VkDevice device, vk::Allocator &allocator, const TestTextureSp &textureData,
159 const Type type, const vk::VkImageAspectFlags aspectMask,
160 const ImageBackingMode backingMode = IMAGE_BACKING_MODE_REGULAR,
161 const vk::VkComponentMapping componentMapping = vk::makeComponentMappingRGBA());
getImage(void)162 vk::VkImage getImage(void)
163 {
164 return *m_textureImage;
165 }
getImageView(void)166 vk::VkImageView getImageView(void)
167 {
168 return *m_textureImageView;
169 }
getType(void)170 Type getType(void)
171 {
172 return m_type;
173 }
getTestTexture(void)174 const pipeline::TestTexture &getTestTexture(void)
175 {
176 return *m_textureData;
177 }
178 void updateTextureViewMipLevels(uint32_t baseLevel, uint32_t maxLevel, float imageViewMinLod = 0.0f);
179
180 private:
181 TextureBinding(const TextureBinding &); // not allowed!
182 TextureBinding &operator=(const TextureBinding &); // not allowed!
183
184 void updateTextureData(const TestTextureSp &textureData, const Type type);
185
186 Context &m_context;
187 vk::VkDevice m_device;
188 vk::Allocator &m_allocator;
189 Type m_type;
190 ImageBackingMode m_backingMode;
191 TestTextureSp m_textureData;
192 vk::Move<vk::VkImage> m_textureImage;
193 de::MovePtr<vk::Allocation> m_textureImageMemory;
194 vk::Move<vk::VkImageView> m_textureImageView;
195 std::vector<de::SharedPtr<vk::Allocation>> m_allocations;
196 vk::VkImageAspectFlags m_aspectMask;
197 vk::VkComponentMapping m_componentMapping;
198 };
199
200 void checkTextureSupport(Context &context, const vk::VkFormat imageFormat,
201 const vk::VkComponentMapping &imageComponents, const vk::VkFormat viewFormat,
202 const vk::VkComponentMapping &viewComponents);
203
204 typedef de::SharedPtr<TextureBinding> TextureBindingSp;
205
206 class TextureRenderer
207 {
208 public:
209 TextureRenderer(Context &context, vk::VkSampleCountFlagBits sampleCount, uint32_t renderWidth,
210 uint32_t renderHeight, vk::VkComponentMapping componentMapping = vk::makeComponentMappingRGBA(),
211 bool requireRobustness2 = false, bool requireImageViewMinLod = false);
212
213 TextureRenderer(Context &context, vk::VkSampleCountFlagBits sampleCount, uint32_t renderWidth,
214 uint32_t renderHeight, uint32_t renderDepth,
215 vk::VkComponentMapping componentMapping = vk::makeComponentMappingRGBA(),
216 vk::VkImageType imageType = vk::VK_IMAGE_TYPE_2D,
217 vk::VkImageViewType imageViewType = vk::VK_IMAGE_VIEW_TYPE_2D,
218 vk::VkFormat imageFormat = vk::VK_FORMAT_R8G8B8A8_UNORM, bool requireRobustness2 = false,
219 bool requireImageViewMinLod = false);
220
221 ~TextureRenderer(void);
222
223 void renderQuad(tcu::Surface &result, int texUnit, const float *texCoord,
224 glu::TextureTestUtil::TextureType texType);
225 void renderQuad(tcu::Surface &result, int texUnit, const float *texCoord,
226 const glu::TextureTestUtil::ReferenceParams ¶ms);
227 void renderQuad(tcu::Surface &result, const float *positions, const int texUnit, const float *texCoord,
228 const glu::TextureTestUtil::ReferenceParams ¶ms, const float maxAnisotropy);
229
230 void renderQuad(const tcu::PixelBufferAccess &result, int texUnit, const float *texCoord,
231 const glu::TextureTestUtil::ReferenceParams ¶ms);
232 void renderQuad(const tcu::PixelBufferAccess &result, const float *positions, const int texUnit,
233 const float *texCoord, const glu::TextureTestUtil::ReferenceParams ¶ms,
234 const float maxAnisotropy);
235
236 void clearImage(vk::VkImage image);
237
238 void add2DTexture(const TestTexture2DSp &texture, const vk::VkImageAspectFlags &aspectMask,
239 TextureBinding::ImageBackingMode backingMode = TextureBinding::IMAGE_BACKING_MODE_REGULAR);
240 const pipeline::TestTexture2D &get2DTexture(int textureIndex) const;
241
242 void addCubeTexture(const TestTextureCubeSp &texture, const vk::VkImageAspectFlags &aspectMask,
243 TextureBinding::ImageBackingMode backingMode = TextureBinding::IMAGE_BACKING_MODE_REGULAR);
244 const pipeline::TestTextureCube &getCubeTexture(int textureIndex) const;
245
246 void add2DArrayTexture(const TestTexture2DArraySp &texture, const vk::VkImageAspectFlags &aspectMask,
247 TextureBinding::ImageBackingMode backingMode = TextureBinding::IMAGE_BACKING_MODE_REGULAR);
248 const pipeline::TestTexture2DArray &get2DArrayTexture(int textureIndex) const;
249
250 void add3DTexture(const TestTexture3DSp &texture, const vk::VkImageAspectFlags &aspectMask,
251 TextureBinding::ImageBackingMode backingMode = TextureBinding::IMAGE_BACKING_MODE_REGULAR);
252 const pipeline::TestTexture3D &get3DTexture(int textureIndex) const;
253
254 void add1DTexture(const TestTexture1DSp &texture, const vk::VkImageAspectFlags &aspectMask,
255 TextureBinding::ImageBackingMode backingMode = TextureBinding::IMAGE_BACKING_MODE_REGULAR);
256 const pipeline::TestTexture1D &get1DTexture(int textureIndex) const;
257
258 void add1DArrayTexture(const TestTexture1DArraySp &texture, const vk::VkImageAspectFlags &aspectMask,
259 TextureBinding::ImageBackingMode backingMode = TextureBinding::IMAGE_BACKING_MODE_REGULAR);
260 const pipeline::TestTexture1DArray &get1DArrayTexture(int textureIndex) const;
261
262 void addCubeArrayTexture(const TestTextureCubeArraySp &texture, const vk::VkImageAspectFlags &aspectMask,
263 TextureBinding::ImageBackingMode backingMode = TextureBinding::IMAGE_BACKING_MODE_REGULAR);
264 const pipeline::TestTextureCubeArray &getCubeArrayTexture(int textureIndex) const;
265
266 void setViewport(float viewportX, float viewportY, float viewportW, float viewportH);
267
268 TextureBinding *getTextureBinding(int textureIndex) const;
269
270 uint32_t getRenderWidth(void) const;
271 uint32_t getRenderHeight(void) const;
272
273 protected:
274 TextureRenderer(const TextureRenderer &other);
275 TextureRenderer &operator=(const TextureRenderer &other);
276
277 Context &m_context;
278 vk::Move<vk::VkDevice> m_customDevice;
279 de::MovePtr<vk::Allocator> m_allocator;
280 tcu::TestLog &m_log;
281
282 const uint32_t m_renderWidth;
283 const uint32_t m_renderHeight;
284 const uint32_t m_renderDepth;
285 const vk::VkSampleCountFlagBits m_sampleCount;
286 const bool m_multisampling;
287
288 const vk::VkFormat m_imageFormat;
289 const tcu::TextureFormat m_textureFormat;
290
291 vk::Move<vk::VkImage> m_image;
292 de::MovePtr<vk::Allocation> m_imageMemory;
293 vk::Move<vk::VkImageView> m_imageView;
294
295 vk::Move<vk::VkImage> m_resolvedImage;
296 de::MovePtr<vk::Allocation> m_resolvedImageMemory;
297 vk::Move<vk::VkImageView> m_resolvedImageView;
298
299 vk::Move<vk::VkCommandPool> m_commandPool;
300 vk::Move<vk::VkRenderPass> m_renderPass;
301 vk::Move<vk::VkFramebuffer> m_frameBuffer;
302
303 vk::Move<vk::VkDescriptorPool> m_descriptorPool;
304 vk::Move<vk::VkDescriptorSet> m_descriptorSet[2];
305 vk::Move<vk::VkDescriptorSetLayout> m_descriptorSetLayout[2];
306 vk::Move<vk::VkPipelineLayout> m_pipelineLayout;
307
308 vk::Move<vk::VkBuffer> m_uniformBuffer;
309 de::MovePtr<vk::Allocation> m_uniformBufferMemory;
310 const vk::VkDeviceSize m_uniformBufferSize;
311
312 vk::Move<vk::VkBuffer> m_vertexIndexBuffer;
313 de::MovePtr<vk::Allocation> m_vertexIndexBufferMemory;
314 static const vk::VkDeviceSize s_vertexIndexBufferSize;
315 static const uint16_t s_vertexIndices[6];
316
317 vk::Move<vk::VkBuffer> m_resultBuffer;
318 de::MovePtr<vk::Allocation> m_resultBufferMemory;
319 const vk::VkDeviceSize m_resultBufferSize;
320
321 std::vector<TextureBindingSp> m_textureBindings;
322
323 float m_viewportOffsetX;
324 float m_viewportOffsetY;
325 float m_viewportWidth;
326 float m_viewportHeight;
327
328 vk::VkComponentMapping m_componentMapping;
329
330 bool m_requireRobustness2;
331 bool m_requireImageViewMinLod;
332
333 private:
334 vk::Move<vk::VkDescriptorSet> makeDescriptorSet(const vk::VkDescriptorPool descriptorPool,
335 const vk::VkDescriptorSetLayout setLayout) const;
336 void addImageTransitionBarrier(vk::VkCommandBuffer commandBuffer, vk::VkImage image,
337 vk::VkPipelineStageFlags srcStageMask, vk::VkPipelineStageFlags dstStageMask,
338 vk::VkAccessFlags srcAccessMask, vk::VkAccessFlags dstAccessMask,
339 vk::VkImageLayout oldLayout, vk::VkImageLayout newLayout) const;
340
341 vk::VkDevice getDevice(void) const;
342 };
343
344 tcu::Sampler createSampler(tcu::Sampler::WrapMode wrapU, tcu::Sampler::WrapMode wrapV, tcu::Sampler::WrapMode wrapW,
345 tcu::Sampler::FilterMode minFilterMode, tcu::Sampler::FilterMode magFilterMode,
346 bool normalizedCoords = true);
347 tcu::Sampler createSampler(tcu::Sampler::WrapMode wrapU, tcu::Sampler::WrapMode wrapV,
348 tcu::Sampler::FilterMode minFilterMode, tcu::Sampler::FilterMode magFilterMode,
349 bool normalizedCoords = true);
350 tcu::Sampler createSampler(tcu::Sampler::WrapMode wrapU, tcu::Sampler::FilterMode minFilterMode,
351 tcu::Sampler::FilterMode magFilterMode, bool normalizedCoords = true);
352
353 TestTexture2DSp loadTexture2D(const tcu::Archive &archive, const std::vector<std::string> &filenames);
354 TestTextureCubeSp loadTextureCube(const tcu::Archive &archive, const std::vector<std::string> &filenames);
355
356 // Add checkTextureSupport() function specialization for your test parameters class/struct if you need to use checkSupport() functionality
357 template <typename T>
checkTextureSupport(Context & context,const T & testParameters)358 void checkTextureSupport(Context &context, const T &testParameters)
359 {
360 DE_UNREF(context);
361 DE_UNREF(testParameters);
362 }
363
364 template <typename INSTANCE_TYPE>
365 class TextureTestCase : public TestCase
366 {
367 public:
TextureTestCase(tcu::TestContext & context,const std::string & name,const typename INSTANCE_TYPE::ParameterType & testParameters)368 TextureTestCase(tcu::TestContext &context, const std::string &name,
369 const typename INSTANCE_TYPE::ParameterType &testParameters)
370 : TestCase(context, name)
371 , m_testsParameters(testParameters)
372 {
373 }
374
createInstance(Context & context) const375 virtual TestInstance *createInstance(Context &context) const
376 {
377 return new INSTANCE_TYPE(context, m_testsParameters);
378 }
379
initPrograms(vk::SourceCollections & programCollection) const380 virtual void initPrograms(vk::SourceCollections &programCollection) const
381 {
382 initializePrograms(programCollection, m_testsParameters.texCoordPrecision, m_testsParameters.programs, DE_NULL,
383 glu::PRECISION_MEDIUMP, m_testsParameters.unnormal);
384 }
385
checkSupport(Context & context) const386 virtual void checkSupport(Context &context) const
387 {
388 checkTextureSupport(context, m_testsParameters);
389 }
390
391 protected:
392 const typename INSTANCE_TYPE::ParameterType m_testsParameters;
393 };
394
395 struct TextureCommonTestCaseParameters
396 {
397 TextureCommonTestCaseParameters(void);
398
399 enum TestType
400 {
401 TEST_NORMAL = 0,
402 TEST_IMAGE_VIEW_MINLOD,
403 TEST_IMAGE_VIEW_MINLOD_INT_TEX_COORD,
404 TEST_IMAGE_VIEW_MINLOD_INT_TEX_COORD_BASELEVEL
405 };
406
407 vk::VkSampleCountFlagBits sampleCount;
408 glu::Precision texCoordPrecision;
409
410 tcu::Sampler::FilterMode minFilter;
411 tcu::Sampler::FilterMode magFilter;
412 tcu::Sampler::WrapMode wrapS;
413
414 vk::VkFormat format;
415
416 std::vector<util::Program> programs;
417
418 bool unnormal;
419 vk::VkImageAspectFlags aspectMask;
420
421 TestType testType;
422 };
423
424 struct Texture2DTestCaseParameters : public TextureCommonTestCaseParameters
425 {
426 Texture2DTestCaseParameters(void);
427 tcu::Sampler::WrapMode wrapT;
428 int width;
429 int height;
430 bool mipmaps;
431 };
432
433 struct TextureCubeTestCaseParameters : public TextureCommonTestCaseParameters
434 {
435 TextureCubeTestCaseParameters(void);
436 tcu::Sampler::WrapMode wrapT;
437 int size;
438 bool seamless;
439 };
440
441 struct Texture2DArrayTestCaseParameters : public Texture2DTestCaseParameters
442 {
443 Texture2DArrayTestCaseParameters(void);
444 tcu::Sampler::WrapMode wrapT;
445 int numLayers;
446 };
447
448 struct Texture3DTestCaseParameters : public Texture2DTestCaseParameters
449 {
450 Texture3DTestCaseParameters(void);
451 tcu::Sampler::WrapMode wrapR;
452 int depth;
453 };
454
455 struct Texture1DTestCaseParameters : public TextureCommonTestCaseParameters
456 {
457 Texture1DTestCaseParameters(void);
458 int width;
459 };
460
461 struct Texture1DArrayTestCaseParameters : public Texture1DTestCaseParameters
462 {
463 Texture1DArrayTestCaseParameters(void);
464 int numLayers;
465 };
466
467 struct TextureCubeArrayTestCaseParameters : public TextureCubeTestCaseParameters
468 {
469 TextureCubeArrayTestCaseParameters(void);
470 int numLayers;
471 };
472
473 struct TextureCubeFilteringTestCaseParameters : public TextureCubeTestCaseParameters
474 {
475 TextureCubeFilteringTestCaseParameters(void);
476 bool onlySampleFaceInterior;
477 };
478
479 } // namespace util
480 } // namespace texture
481 } // namespace vkt
482
483 #endif // _VKTTEXTURETESTUTIL_HPP
484