external/vulkancts/modules/vulkan/pipeline/vktPipelineImageUtil.hpp

   1 #ifndef _VKTPIPELINEIMAGEUTIL_HPP
   2 #define _VKTPIPELINEIMAGEUTIL_HPP
   3 /*------------------------------------------------------------------------
   4  * Vulkan Conformance Tests
   5  * ------------------------
   6  *
   7  * Copyright (c) 2015 The Khronos Group Inc.
   8  * Copyright (c) 2015 Imagination Technologies Ltd.
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  *//*!
  23  * \file
  24  * \brief Utilities for images.
  25  *//*--------------------------------------------------------------------*/
  26
  27 #include "tcuDefs.hpp"
  28 #include "vkDefs.hpp"
  29 #include "vkDefs.hpp"
  30 #include "vkPlatform.hpp"
  31 #include "vkMemUtil.hpp"
  32 #include "vkRef.hpp"
  33 #include "tcuTexture.hpp"
  34 #include "tcuCompressedTexture.hpp"
  35 #include "deSharedPtr.hpp"
  36
  37 namespace vkt
  38 {
  39 namespace pipeline
  40 {
  41
  42 class TestTexture;
  43
  44 enum BorderColor
  45 {
  46         BORDER_COLOR_OPAQUE_BLACK,
  47         BORDER_COLOR_OPAQUE_WHITE,
  48         BORDER_COLOR_TRANSPARENT_BLACK,
  49
  50         BORDER_COLOR_COUNT
  51 };
  52
  53 bool                                                    isSupportedSamplableFormat      (const vk::InstanceInterface&   instanceInterface,
  54                                                                                                                          vk::VkPhysicalDevice                   device,
  55                                                                                                                          vk::VkFormat                                   format);
  56 bool                                                    isLinearFilteringSupported      (const vk::InstanceInterface&   instanceInterface,
  57                                                                                                                          vk::VkPhysicalDevice                   device,
  58                                                                                                                          vk::VkFormat                                   format,
  59                                                                                                                          vk::VkImageTiling                              tiling);
  60
  61 vk::VkBorderColor                               getFormatBorderColor            (BorderColor color, vk::VkFormat format);
  62
  63 void                                                    getLookupScaleBias                      (vk::VkFormat                                   format,
  64                                                                                                                          tcu::Vec4&                                             lookupScale,
  65                                                                                                                          tcu::Vec4&                                             lookupBias);
  66
  67 /*--------------------------------------------------------------------*//*!
  68  * Gets a tcu::TextureLevel initialized with data from a VK color
  69  * attachment.
  70  *
  71  * The VkImage must be non-multisampled and able to be used as a source
  72  * operand for transfer operations.
  73  *//*--------------------------------------------------------------------*/
  74 de::MovePtr<tcu::TextureLevel>  readColorAttachment                      (const vk::DeviceInterface&    vk,
  75                                                                                                                           vk::VkDevice                                  device,
  76                                                                                                                           vk::VkQueue                                   queue,
  77                                                                                                                           deUint32                                              queueFamilyIndex,
  78                                                                                                                           vk::Allocator&                                allocator,
  79                                                                                                                           vk::VkImage                                   image,
  80                                                                                                                           vk::VkFormat                                  format,
  81                                                                                                                           const tcu::UVec2&                             renderSize);
  82
  83 /*--------------------------------------------------------------------*//*!
  84  * Uploads data from a test texture to a destination VK image.
  85  *
  86  * The VkImage must be non-multisampled and able to be used as a
  87  * destination operand for transfer operations.
  88  *//*--------------------------------------------------------------------*/
  89 void                                                    uploadTestTexture                       (const vk::DeviceInterface&             vk,
  90                                                                                                                          vk::VkDevice                                   device,
  91                                                                                                                          vk::VkQueue                                    queue,
  92                                                                                                                          deUint32                                               queueFamilyIndex,
  93                                                                                                                          vk::Allocator&                                 allocator,
  94                                                                                                                          const TestTexture&                             testTexture,
  95                                                                                                                          vk::VkImage                                    destImage);
  96
  97 /*--------------------------------------------------------------------*//*!
  98  * Uploads data from a test texture to a destination VK image using sparse
  99  * binding.
 100  *
 101  * The VkImage must be non-multisampled and able to be used as a
 102  * destination operand for transfer operations.
 103  *//*--------------------------------------------------------------------*/
 104 void                                                    uploadTestTextureSparse         (const vk::DeviceInterface&                                             vk,
 105                                                                                                                          vk::VkDevice                                                                   device,
 106                                                                                                                          const vk::VkPhysicalDevice                                             physicalDevice,
 107                                                                                                                          const vk::InstanceInterface&                                   instance,
 108                                                                                                                          const vk::VkImageCreateInfo&                                   imageCreateInfo,
 109                                                                                                                          vk::VkQueue                                                                    queue,
 110                                                                                                                          deUint32                                                                               queueFamilyIndex,
 111                                                                                                                          vk::Allocator&                                                                 allocator,
 112                                                                                                                          std::vector<de::SharedPtr<vk::Allocation> >&   allocations,
 113                                                                                                                          const TestTexture&                                                             srcTexture,
 114                                                                                                                          vk::VkImage                                                                    destImage);
 115
 116 class TestTexture
 117 {
 118 public:
 119                                                                                                 TestTexture                                     (const tcu::TextureFormat& format, int width, int height, int depth);
 120                                                                                                 TestTexture                                     (const tcu::CompressedTexFormat& format, int width, int height, int depth);
 121         virtual                                                                         ~TestTexture                            (void);
 122
 123         virtual int                                                                     getNumLevels                            (void) const = 0;
 124         virtual deUint32                                                        getSize                                         (void) const;
 125         virtual int                                                                     getArraySize                            (void) const { return 1; }
 126
 127         virtual bool                                                            isCompressed                            (void) const { return !m_compressedLevels.empty(); }
 128         virtual deUint32                                                        getCompressedSize                       (void) const;
 129
 130         virtual tcu::PixelBufferAccess                          getLevel                                        (int level, int layer) = 0;
 131         virtual const tcu::ConstPixelBufferAccess       getLevel                                        (int level, int layer) const = 0;
 132
 133         virtual tcu::CompressedTexture&                         getCompressedLevel                      (int level, int layer);
 134         virtual const tcu::CompressedTexture&           getCompressedLevel                      (int level, int layer) const;
 135
 136         virtual std::vector<vk::VkBufferImageCopy>      getBufferCopyRegions            (void) const;
 137         virtual void                                                            write                                           (deUint8* destPtr) const;
 138         virtual de::MovePtr<TestTexture>                        copy                                            (const tcu::TextureFormat) const = 0;
 139
 140         virtual const tcu::TextureFormat&                       getTextureFormat                        (void) const = 0;
 141         virtual tcu::UVec3                                                      getTextureDimension                     (void) const = 0;
 142
 143 protected:
 144         void                                                                            populateLevels                          (const std::vector<tcu::PixelBufferAccess>& levels);
 145         void                                                                            populateCompressedLevels        (tcu::CompressedTexFormat format, const std::vector<tcu::PixelBufferAccess>& decompressedLevels);
 146
 147         static void                                                                     fillWithGradient                        (const tcu::PixelBufferAccess& levelAccess);
 148
 149         void                                                                            copyToTexture                           (TestTexture&) const;
 150
 151 protected:
 152         std::vector<tcu::CompressedTexture*>            m_compressedLevels;
 153 };
 154
 155 class TestTexture1D : public TestTexture
 156 {
 157 private:
 158         tcu::Texture1D                                                          m_texture;
 159
 160 public:
 161                                                                                                 TestTexture1D           (const tcu::TextureFormat& format, int width);
 162                                                                                                 TestTexture1D           (const tcu::CompressedTexFormat& format, int width);
 163         virtual                                                                         ~TestTexture1D          (void);
 164
 165         virtual int getNumLevels (void) const;
 166         virtual tcu::PixelBufferAccess                          getLevel                        (int level, int layer);
 167         virtual const tcu::ConstPixelBufferAccess       getLevel                        (int level, int layer) const;
 168         virtual const tcu::Texture1D&                           getTexture                      (void) const;
 169         virtual tcu::Texture1D&                                         getTexture                      (void);
 170         virtual const tcu::TextureFormat&                       getTextureFormat        (void) const { return m_texture.getFormat(); }
 171         virtual tcu::UVec3                                                      getTextureDimension     (void) const { return tcu::UVec3(m_texture.getWidth(), 1, 1); }
 172
 173         virtual de::MovePtr<TestTexture>                        copy                            (const tcu::TextureFormat) const;
 174 };
 175
 176 class TestTexture1DArray : public TestTexture
 177 {
 178 private:
 179         tcu::Texture1DArray                                                     m_texture;
 180
 181 public:
 182                                                                                                 TestTexture1DArray      (const tcu::TextureFormat& format, int width, int arraySize);
 183                                                                                                 TestTexture1DArray      (const tcu::CompressedTexFormat& format, int width, int arraySize);
 184         virtual                                                                         ~TestTexture1DArray     (void);
 185
 186         virtual int                                                                     getNumLevels            (void) const;
 187         virtual tcu::PixelBufferAccess                          getLevel                        (int level, int layer);
 188         virtual const tcu::ConstPixelBufferAccess       getLevel                        (int level, int layer) const;
 189         virtual const tcu::Texture1DArray&                      getTexture                      (void) const;
 190         virtual tcu::Texture1DArray&                            getTexture                      (void);
 191         virtual int                                                                     getArraySize            (void) const;
 192         virtual const tcu::TextureFormat&                       getTextureFormat        (void) const { return m_texture.getFormat(); }
 193         virtual tcu::UVec3                                                      getTextureDimension     (void) const { return tcu::UVec3(m_texture.getWidth(), 1, 1); }
 194
 195         virtual de::MovePtr<TestTexture>                        copy                            (const tcu::TextureFormat) const;
 196 };
 197
 198 class TestTexture2D : public TestTexture
 199 {
 200 private:
 201         tcu::Texture2D                                                          m_texture;
 202
 203 public:
 204                                                                                                 TestTexture2D           (const tcu::TextureFormat& format, int width, int height);
 205                                                                                                 TestTexture2D           (const tcu::CompressedTexFormat& format, int width, int height);
 206         virtual                                                                         ~TestTexture2D          (void);
 207
 208         virtual int                                                                     getNumLevels            (void) const;
 209         virtual tcu::PixelBufferAccess                          getLevel                        (int level, int layer);
 210         virtual const tcu::ConstPixelBufferAccess       getLevel                        (int level, int layer) const;
 211         virtual const tcu::Texture2D&                           getTexture                      (void) const;
 212         virtual tcu::Texture2D&                                         getTexture                      (void);
 213         virtual const tcu::TextureFormat&                       getTextureFormat        (void) const { return m_texture.getFormat(); }
 214         virtual tcu::UVec3                                                      getTextureDimension     (void) const { return tcu::UVec3(m_texture.getWidth(), m_texture.getHeight(), 1); }
 215
 216         virtual de::MovePtr<TestTexture>                        copy                            (const tcu::TextureFormat) const;
 217 };
 218
 219 class TestTexture2DArray : public TestTexture
 220 {
 221 private:
 222         tcu::Texture2DArray     m_texture;
 223
 224 public:
 225                                                                                                 TestTexture2DArray      (const tcu::TextureFormat& format, int width, int height, int arraySize);
 226                                                                                                 TestTexture2DArray      (const tcu::CompressedTexFormat& format, int width, int height, int arraySize);
 227         virtual                                                                         ~TestTexture2DArray     (void);
 228
 229         virtual int                                                                     getNumLevels            (void) const;
 230         virtual tcu::PixelBufferAccess                          getLevel                        (int level, int layer);
 231         virtual const tcu::ConstPixelBufferAccess       getLevel                        (int level, int layer) const;
 232         virtual const tcu::Texture2DArray&                      getTexture                      (void) const;
 233         virtual tcu::Texture2DArray&                            getTexture                      (void);
 234         virtual int                                                                     getArraySize            (void) const;
 235         virtual const tcu::TextureFormat&                       getTextureFormat        (void) const { return m_texture.getFormat(); }
 236         virtual tcu::UVec3                                                      getTextureDimension     (void) const { return tcu::UVec3(m_texture.getWidth(), m_texture.getHeight(), 1); }
 237
 238         virtual de::MovePtr<TestTexture>                        copy                            (const tcu::TextureFormat) const;
 239 };
 240
 241 class TestTexture3D : public TestTexture
 242 {
 243 private:
 244         tcu::Texture3D  m_texture;
 245
 246 public:
 247                                                                                                 TestTexture3D           (const tcu::TextureFormat& format, int width, int height, int depth);
 248                                                                                                 TestTexture3D           (const tcu::CompressedTexFormat& format, int width, int height, int depth);
 249         virtual                                                                         ~TestTexture3D          (void);
 250
 251         virtual int                                                                     getNumLevels            (void) const;
 252         virtual tcu::PixelBufferAccess                          getLevel                        (int level, int layer);
 253         virtual const tcu::ConstPixelBufferAccess       getLevel                        (int level, int layer) const;
 254         virtual const tcu::Texture3D&                           getTexture                      (void) const;
 255         virtual tcu::Texture3D&                                         getTexture                      (void);
 256         virtual const tcu::TextureFormat&                       getTextureFormat        (void) const { return m_texture.getFormat(); }
 257         virtual tcu::UVec3                                                      getTextureDimension     (void) const { return tcu::UVec3(m_texture.getWidth(), m_texture.getHeight(), m_texture.getDepth()); }
 258
 259         virtual de::MovePtr<TestTexture>                        copy                            (const tcu::TextureFormat) const;
 260 };
 261
 262 class TestTextureCube : public TestTexture
 263 {
 264 private:
 265         tcu::TextureCube                                                        m_texture;
 266
 267 public:
 268                                                                                                 TestTextureCube                 (const tcu::TextureFormat& format, int size);
 269                                                                                                 TestTextureCube                 (const tcu::CompressedTexFormat& format, int size);
 270         virtual                                                                         ~TestTextureCube                (void);
 271
 272         virtual int                                                                     getNumLevels                    (void) const;
 273         virtual tcu::PixelBufferAccess                          getLevel                                (int level, int layer);
 274         virtual const tcu::ConstPixelBufferAccess       getLevel                                (int level, int layer) const;
 275         virtual int                                                                     getArraySize                    (void) const;
 276         virtual const tcu::TextureCube&                         getTexture                              (void) const;
 277         virtual tcu::TextureCube&                                       getTexture                              (void);
 278         virtual const tcu::TextureFormat&                       getTextureFormat                (void) const { return m_texture.getFormat(); }
 279         virtual tcu::UVec3                                                      getTextureDimension             (void) const { return tcu::UVec3(m_texture.getSize(), m_texture.getSize(), 1); }
 280
 281         virtual de::MovePtr<TestTexture>                        copy                                    (const tcu::TextureFormat) const;
 282 };
 283
 284 class TestTextureCubeArray: public TestTexture
 285 {
 286 private:
 287         tcu::TextureCubeArray                                           m_texture;
 288
 289 public:
 290                                                                                                 TestTextureCubeArray    (const tcu::TextureFormat& format, int size, int arraySize);
 291                                                                                                 TestTextureCubeArray    (const tcu::CompressedTexFormat& format, int size, int arraySize);
 292         virtual                                                                         ~TestTextureCubeArray   (void);
 293
 294         virtual int                                                                     getNumLevels                    (void) const;
 295         virtual tcu::PixelBufferAccess                          getLevel                                (int level, int layer);
 296         virtual const tcu::ConstPixelBufferAccess       getLevel                                (int level, int layer) const;
 297         virtual int                                                                     getArraySize                    (void) const;
 298         virtual const tcu::TextureCubeArray&            getTexture                              (void) const;
 299         virtual tcu::TextureCubeArray&                          getTexture                              (void);
 300         virtual const tcu::TextureFormat&                       getTextureFormat                (void) const { return m_texture.getFormat(); }
 301         virtual tcu::UVec3                                                      getTextureDimension             (void) const { return tcu::UVec3(m_texture.getSize(), m_texture.getSize(), 1); }
 302
 303         virtual de::MovePtr<TestTexture>                        copy                                    (const tcu::TextureFormat) const;
 304 };
 305
 306 } // pipeline
 307 } // vkt
 308
 309 #endif // _VKTPIPELINEIMAGEUTIL_HPP