tests/vkrenderframework.h

   1 /*
   2  * Copyright (c) 2015-2017 The Khronos Group Inc.
   3  * Copyright (c) 2015-2017 Valve Corporation
   4  * Copyright (c) 2015-2017 LunarG, Inc.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
  19  * Author: Dave Houlton <daveh@lunarg.com>
  20  */
  21
  22 #ifndef VKRENDERFRAMEWORK_H
  23 #define VKRENDERFRAMEWORK_H
  24
  25 #ifdef ANDROID
  26 #include "vktestframeworkandroid.h"
  27 class VkImageObj;
  28 #else
  29 #include "vktestframework.h"
  30 #endif
  31
  32 #include <algorithm>
  33 #include <array>
  34 #include <map>
  35 #include <memory>
  36 #include <vector>
  37
  38 using namespace std;
  39
  40 using vk_testing::MakeVkHandles;
  41
  42 template <class Dst, class Src>
  43 std::vector<Dst *> MakeTestbindingHandles(const std::vector<Src *> &v) {
  44     std::vector<Dst *> handles;
  45     handles.reserve(v.size());
  46     std::transform(v.begin(), v.end(), std::back_inserter(handles), [](const Src *o) { return static_cast<Dst *>(o); });
  47     return handles;
  48 }
  49
  50 typedef vk_testing::Queue VkQueueObj;
  51 class VkDeviceObj : public vk_testing::Device {
  52    public:
  53     VkDeviceObj(uint32_t id, VkPhysicalDevice obj);
  54     VkDeviceObj(uint32_t id, VkPhysicalDevice obj, std::vector<const char *> &extension_names,
  55                 VkPhysicalDeviceFeatures *features = nullptr, VkPhysicalDeviceFeatures2KHR *features2 = nullptr);
  56
  57     uint32_t QueueFamilyMatching(VkQueueFlags with, VkQueueFlags without, bool all_bits = true);
  58     uint32_t QueueFamilyWithoutCapabilities(VkQueueFlags capabilities) {
  59         // an all_bits match with 0 matches all
  60         return QueueFamilyMatching(VkQueueFlags(0), capabilities, true /* all_bits with */);
  61     }
  62
  63     VkDevice device() { return handle(); }
  64     void SetDeviceQueue();
  65     VkQueueObj *GetDefaultQueue();
  66
  67     uint32_t id;
  68     VkPhysicalDeviceProperties props;
  69     std::vector<VkQueueFamilyProperties> queue_props;
  70
  71     VkQueue m_queue;
  72 };
  73
  74 class VkCommandPoolObj;
  75 class VkCommandBufferObj;
  76 class VkDepthStencilObj;
  77
  78 class VkRenderFramework : public VkTestFramework {
  79    public:
  80     VkRenderFramework();
  81     ~VkRenderFramework();
  82
  83     VkInstance instance() { return inst; }
  84     VkDevice device() { return m_device->device(); }
  85     VkDeviceObj *DeviceObj() const { return m_device; }
  86     VkPhysicalDevice gpu();
  87     VkRenderPass renderPass() { return m_renderPass; }
  88     const VkRenderPassCreateInfo &RenderPassInfo() const { return renderPass_info_; };
  89     VkFramebuffer framebuffer() { return m_framebuffer; }
  90     void InitViewport(float width, float height);
  91     void InitViewport();
  92     void InitRenderTarget();
  93     void InitRenderTarget(uint32_t targets);
  94     void InitRenderTarget(VkImageView *dsBinding);
  95     void InitRenderTarget(uint32_t targets, VkImageView *dsBinding);
  96     void InitFramework(PFN_vkDebugReportCallbackEXT = NULL, void *userData = NULL);
  97
  98     void ShutdownFramework();
  99     void GetPhysicalDeviceFeatures(VkPhysicalDeviceFeatures *features);
 100     void InitState(VkPhysicalDeviceFeatures *features = nullptr, VkPhysicalDeviceFeatures2 *features2 = nullptr,
 101                    const VkCommandPoolCreateFlags flags = 0);
 102
 103     const VkRenderPassBeginInfo &renderPassBeginInfo() const { return m_renderPassBeginInfo; }
 104
 105     bool InstanceLayerSupported(const char *name, uint32_t specVersion = 0, uint32_t implementationVersion = 0);
 106     bool EnableDeviceProfileLayer();
 107     bool InstanceExtensionSupported(const char *name, uint32_t specVersion = 0);
 108     bool InstanceExtensionEnabled(const char *name);
 109     bool DeviceExtensionSupported(VkPhysicalDevice dev, const char *layer, const char *name, uint32_t specVersion = 0);
 110     bool DeviceExtensionEnabled(const char *name);
 111
 112    protected:
 113     VkApplicationInfo app_info;
 114     VkInstance inst;
 115     VkPhysicalDevice objs[16];
 116     uint32_t gpu_count;
 117     VkDeviceObj *m_device;
 118     VkCommandPoolObj *m_commandPool;
 119     VkCommandBufferObj *m_commandBuffer;
 120     VkRenderPass m_renderPass;
 121     VkRenderPassCreateInfo renderPass_info_ = {};
 122     VkFramebuffer m_framebuffer;
 123     std::vector<VkViewport> m_viewports;
 124     std::vector<VkRect2D> m_scissors;
 125     float m_lineWidth;
 126     float m_depthBiasConstantFactor;
 127     float m_depthBiasClamp;
 128     float m_depthBiasSlopeFactor;
 129     float m_blendConstants[4];
 130     float m_minDepthBounds;
 131     float m_maxDepthBounds;
 132     uint32_t m_compareMask;
 133     uint32_t m_writeMask;
 134     uint32_t m_reference;
 135     bool m_addRenderPassSelfDependency;
 136     std::vector<VkClearValue> m_renderPassClearValues;
 137     VkRenderPassBeginInfo m_renderPassBeginInfo;
 138     vector<std::unique_ptr<VkImageObj>> m_renderTargets;
 139     float m_width, m_height;
 140     VkFormat m_render_target_fmt;
 141     VkFormat m_depth_stencil_fmt;
 142     VkClearColorValue m_clear_color;
 143     bool m_clear_via_load_op;
 144     float m_depth_clear_color;
 145     uint32_t m_stencil_clear_color;
 146     VkDepthStencilObj *m_depthStencil;
 147     PFN_vkCreateDebugReportCallbackEXT m_CreateDebugReportCallback;
 148     PFN_vkDestroyDebugReportCallbackEXT m_DestroyDebugReportCallback;
 149     PFN_vkDebugReportMessageEXT m_DebugReportMessage;
 150     VkDebugReportCallbackEXT m_globalMsgCallback;
 151     VkDebugReportCallbackEXT m_devMsgCallback;
 152
 153     std::vector<const char *> m_instance_layer_names;
 154     std::vector<const char *> m_instance_extension_names;
 155     std::vector<const char *> m_device_extension_names;
 156
 157     /*
 158      * SetUp and TearDown are called by the Google Test framework
 159      * to initialize a test framework based on this class.
 160      */
 161     virtual void SetUp() {
 162         this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
 163         this->app_info.pNext = NULL;
 164         this->app_info.pApplicationName = "base";
 165         this->app_info.applicationVersion = 1;
 166         this->app_info.pEngineName = "unittest";
 167         this->app_info.engineVersion = 1;
 168         this->app_info.apiVersion = VK_API_VERSION_1_0;
 169
 170         InitFramework();
 171     }
 172
 173     virtual void TearDown() { ShutdownFramework(); }
 174 };
 175
 176 class VkDescriptorSetObj;
 177 class VkConstantBufferObj;
 178 class VkPipelineObj;
 179 class VkDescriptorSetObj;
 180 typedef vk_testing::Fence VkFenceObj;
 181
 182 class VkCommandPoolObj : public vk_testing::CommandPool {
 183    public:
 184     VkCommandPoolObj(VkDeviceObj *device, uint32_t queue_family_index, VkCommandPoolCreateFlags flags = 0);
 185 };
 186
 187 class VkCommandBufferObj : public vk_testing::CommandBuffer {
 188    public:
 189     VkCommandBufferObj(VkDeviceObj *device, VkCommandPoolObj *pool, VkCommandBufferLevel level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
 190                        VkQueueObj *queue = nullptr);
 191     void PipelineBarrier(VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages, VkDependencyFlags dependencyFlags,
 192                          uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount,
 193                          const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount,
 194                          const VkImageMemoryBarrier *pImageMemoryBarriers);
 195     void ClearAllBuffers(const vector<std::unique_ptr<VkImageObj>> &color_objs, VkClearColorValue clear_color,
 196                          VkDepthStencilObj *depth_stencil_obj, float depth_clear_value, uint32_t stencil_clear_value);
 197     void PrepareAttachments(const vector<std::unique_ptr<VkImageObj>> &color_atts, VkDepthStencilObj *depth_stencil_att);
 198     void BindDescriptorSet(VkDescriptorSetObj &descriptorSet);
 199     void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding);
 200     void BeginRenderPass(const VkRenderPassBeginInfo &info);
 201     void EndRenderPass();
 202     void FillBuffer(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize fill_size, uint32_t data);
 203     void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
 204     void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
 205                      uint32_t firstInstance);
 206     void QueueCommandBuffer(bool checkSuccess = true);
 207     void QueueCommandBuffer(const VkFenceObj &fence, bool checkSuccess = true);
 208     void SetViewport(uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports);
 209     void SetStencilReference(VkStencilFaceFlags faceMask, uint32_t reference);
 210     void UpdateBuffer(VkBuffer buffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData);
 211     void CopyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
 212                    uint32_t regionCount, const VkImageCopy *pRegions);
 213     void ResolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
 214                       uint32_t regionCount, const VkImageResolve *pRegions);
 215     void ClearColorImage(VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount,
 216                          const VkImageSubresourceRange *pRanges);
 217     void ClearDepthStencilImage(VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pColor,
 218                                 uint32_t rangeCount, const VkImageSubresourceRange *pRanges);
 219
 220    protected:
 221     VkDeviceObj *m_device;
 222     VkQueueObj *m_queue;
 223 };
 224
 225 class VkConstantBufferObj : public vk_testing::Buffer {
 226    public:
 227     VkConstantBufferObj(VkDeviceObj *device,
 228                         VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 229     VkConstantBufferObj(VkDeviceObj *device, VkDeviceSize size, const void *data,
 230                         VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
 231
 232     VkDescriptorBufferInfo m_descriptorBufferInfo;
 233
 234    protected:
 235     VkDeviceObj *m_device;
 236 };
 237
 238 class VkRenderpassObj {
 239    public:
 240     VkRenderpassObj(VkDeviceObj *device);
 241     ~VkRenderpassObj();
 242     VkRenderPass handle() { return m_renderpass; }
 243
 244    protected:
 245     VkRenderPass m_renderpass;
 246     VkDevice device;
 247 };
 248
 249 class VkImageObj : public vk_testing::Image {
 250    public:
 251     VkImageObj(VkDeviceObj *dev);
 252     bool IsCompatible(VkImageUsageFlags usages, VkFormatFeatureFlags features);
 253
 254    public:
 255     void Init(uint32_t const width, uint32_t const height, uint32_t const mipLevels, VkFormat const format, VkFlags const usage,
 256               VkImageTiling const tiling = VK_IMAGE_TILING_LINEAR, VkMemoryPropertyFlags const reqs = 0,
 257               const std::vector<uint32_t> *queue_families = nullptr);
 258
 259     void init(const VkImageCreateInfo *create_info);
 260
 261     void InitNoLayout(uint32_t const width, uint32_t const height, uint32_t const mipLevels, VkFormat const format,
 262                       VkFlags const usage, VkImageTiling tiling = VK_IMAGE_TILING_LINEAR, VkMemoryPropertyFlags reqs = 0,
 263                       const std::vector<uint32_t> *queue_families = nullptr);
 264
 265     //    void clear( CommandBuffer*, uint32_t[4] );
 266
 267     void Layout(VkImageLayout const layout) { m_descriptorImageInfo.imageLayout = layout; }
 268
 269     VkDeviceMemory memory() const { return Image::memory().handle(); }
 270
 271     void *MapMemory() { return Image::memory().map(); }
 272
 273     void UnmapMemory() { Image::memory().unmap(); }
 274
 275     void ImageMemoryBarrier(VkCommandBufferObj *cmd, VkImageAspectFlags aspect, VkFlags output_mask, VkFlags input_mask,
 276                             VkImageLayout image_layout);
 277
 278     VkResult CopyImage(VkImageObj &src_image);
 279
 280     VkImage image() const { return handle(); }
 281
 282     VkImageView targetView(VkFormat format) {
 283         if (!m_targetView.initialized()) {
 284             VkImageViewCreateInfo createView = {};
 285             createView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
 286             createView.image = handle();
 287             createView.viewType = VK_IMAGE_VIEW_TYPE_2D;
 288             createView.format = format;
 289             createView.components.r = VK_COMPONENT_SWIZZLE_R;
 290             createView.components.g = VK_COMPONENT_SWIZZLE_G;
 291             createView.components.b = VK_COMPONENT_SWIZZLE_B;
 292             createView.components.a = VK_COMPONENT_SWIZZLE_A;
 293             createView.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
 294             createView.flags = 0;
 295             m_targetView.init(*m_device, createView);
 296         }
 297         return m_targetView.handle();
 298     }
 299
 300     void SetLayout(VkCommandBufferObj *cmd_buf, VkImageAspectFlags aspect, VkImageLayout image_layout);
 301     void SetLayout(VkImageAspectFlags aspect, VkImageLayout image_layout);
 302
 303     VkImageLayout Layout() const { return m_descriptorImageInfo.imageLayout; }
 304     uint32_t width() const { return extent().width; }
 305     uint32_t height() const { return extent().height; }
 306     VkDeviceObj *device() const { return m_device; }
 307
 308    protected:
 309     VkDeviceObj *m_device;
 310
 311     vk_testing::ImageView m_targetView;
 312     VkDescriptorImageInfo m_descriptorImageInfo;
 313 };
 314
 315 class VkTextureObj : public VkImageObj {
 316    public:
 317     VkTextureObj(VkDeviceObj *device, uint32_t *colors = NULL);
 318
 319     VkDescriptorImageInfo m_imageInfo;
 320
 321    protected:
 322     VkDeviceObj *m_device;
 323     vk_testing::ImageView m_textureView;
 324 };
 325
 326 class VkDepthStencilObj : public VkImageObj {
 327    public:
 328     VkDepthStencilObj(VkDeviceObj *device);
 329     void Init(VkDeviceObj *device, int32_t width, int32_t height, VkFormat format,
 330               VkImageUsageFlags usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
 331     bool Initialized();
 332     VkImageView *BindInfo();
 333
 334     VkFormat Format() const;
 335
 336    protected:
 337     VkDeviceObj *m_device;
 338     bool m_initialized;
 339     vk_testing::ImageView m_imageView;
 340     VkFormat m_depth_stencil_fmt;
 341     VkImageView m_attachmentBindInfo;
 342 };
 343
 344 class VkSamplerObj : public vk_testing::Sampler {
 345    public:
 346     VkSamplerObj(VkDeviceObj *device);
 347
 348    protected:
 349     VkDeviceObj *m_device;
 350 };
 351
 352 class VkDescriptorSetLayoutObj : public vk_testing::DescriptorSetLayout {
 353    public:
 354     VkDescriptorSetLayoutObj() = default;
 355     VkDescriptorSetLayoutObj(const VkDeviceObj *device,
 356                              const std::vector<VkDescriptorSetLayoutBinding> &descriptor_set_bindings = {},
 357                              VkDescriptorSetLayoutCreateFlags flags = 0);
 358
 359     // Move constructor and move assignment operator for Visual Studio 2013
 360     VkDescriptorSetLayoutObj(VkDescriptorSetLayoutObj &&src) : DescriptorSetLayout(std::move(src)){};
 361     VkDescriptorSetLayoutObj &operator=(VkDescriptorSetLayoutObj &&src) {
 362         DescriptorSetLayout::operator=(std::move(src));
 363         return *this;
 364     }
 365 };
 366
 367 class VkDescriptorSetObj : public vk_testing::DescriptorPool {
 368    public:
 369     VkDescriptorSetObj(VkDeviceObj *device);
 370     ~VkDescriptorSetObj();
 371
 372     int AppendDummy();
 373     int AppendBuffer(VkDescriptorType type, VkConstantBufferObj &constantBuffer);
 374     int AppendSamplerTexture(VkSamplerObj *sampler, VkTextureObj *texture);
 375     void CreateVKDescriptorSet(VkCommandBufferObj *commandBuffer);
 376
 377     VkDescriptorSet GetDescriptorSetHandle() const;
 378     VkPipelineLayout GetPipelineLayout() const;
 379
 380    protected:
 381     VkDeviceObj *m_device;
 382     std::vector<VkDescriptorSetLayoutBinding> m_layout_bindings;
 383     std::map<VkDescriptorType, int> m_type_counts;
 384     int m_nextSlot;
 385
 386     vector<VkDescriptorImageInfo> m_imageSamplerDescriptors;
 387     vector<VkWriteDescriptorSet> m_writes;
 388
 389     vk_testing::DescriptorSetLayout m_layout;
 390     vk_testing::PipelineLayout m_pipeline_layout;
 391     vk_testing::DescriptorSet *m_set = NULL;
 392 };
 393
 394 class VkShaderObj : public vk_testing::ShaderModule {
 395    public:
 396     VkShaderObj(VkDeviceObj *device, const char *shaderText, VkShaderStageFlagBits stage, VkRenderFramework *framework,
 397                 char const *name = "main");
 398     VkPipelineShaderStageCreateInfo const &GetStageCreateInfo() const;
 399
 400    protected:
 401     VkPipelineShaderStageCreateInfo m_stage_info;
 402     VkDeviceObj *m_device;
 403 };
 404
 405 class VkPipelineLayoutObj : public vk_testing::PipelineLayout {
 406    public:
 407     VkPipelineLayoutObj() = default;
 408     VkPipelineLayoutObj(VkDeviceObj *device, const std::vector<const VkDescriptorSetLayoutObj *> &descriptor_layouts = {},
 409                         const std::vector<VkPushConstantRange> &push_constant_ranges = {});
 410
 411     // Move constructor and move assignment operator for Visual Studio 2013
 412     VkPipelineLayoutObj(VkPipelineLayoutObj &&src) : PipelineLayout(std::move(src)) {}
 413     VkPipelineLayoutObj &operator=(VkPipelineLayoutObj &&src) {
 414         PipelineLayout::operator=(std::move(src));
 415         return *this;
 416     }
 417
 418     void Reset();
 419 };
 420
 421 class VkPipelineObj : public vk_testing::Pipeline {
 422    public:
 423     VkPipelineObj(VkDeviceObj *device);
 424     void AddShader(VkShaderObj *shaderObj);
 425     void AddShader(VkPipelineShaderStageCreateInfo const &createInfo);
 426     void AddVertexInputAttribs(VkVertexInputAttributeDescription *vi_attrib, uint32_t count);
 427     void AddVertexInputBindings(VkVertexInputBindingDescription *vi_binding, uint32_t count);
 428     void AddColorAttachment(uint32_t binding, const VkPipelineColorBlendAttachmentState &att);
 429     void MakeDynamic(VkDynamicState state);
 430
 431     void AddDefaultColorAttachment(VkColorComponentFlags writeMask = 0xf /*=R|G|B|A*/) {
 432         VkPipelineColorBlendAttachmentState att = {};
 433         att.blendEnable = VK_FALSE;
 434         att.colorWriteMask = writeMask;
 435         AddColorAttachment(0, att);
 436     }
 437
 438     void SetDepthStencil(const VkPipelineDepthStencilStateCreateInfo *);
 439     void SetMSAA(const VkPipelineMultisampleStateCreateInfo *ms_state);
 440     void SetInputAssembly(const VkPipelineInputAssemblyStateCreateInfo *ia_state);
 441     void SetRasterization(const VkPipelineRasterizationStateCreateInfo *rs_state);
 442     void SetTessellation(const VkPipelineTessellationStateCreateInfo *te_state);
 443     void SetViewport(const vector<VkViewport> viewports);
 444     void SetScissor(const vector<VkRect2D> scissors);
 445
 446     void InitGraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo *gp_ci);
 447
 448     VkResult CreateVKPipeline(VkPipelineLayout layout, VkRenderPass render_pass, VkGraphicsPipelineCreateInfo *gp_ci = nullptr);
 449
 450    protected:
 451     VkPipelineVertexInputStateCreateInfo m_vi_state;
 452     VkPipelineInputAssemblyStateCreateInfo m_ia_state;
 453     VkPipelineRasterizationStateCreateInfo m_rs_state;
 454     VkPipelineColorBlendStateCreateInfo m_cb_state;
 455     VkPipelineDepthStencilStateCreateInfo const *m_ds_state;
 456     VkPipelineViewportStateCreateInfo m_vp_state;
 457     VkPipelineMultisampleStateCreateInfo m_ms_state;
 458     VkPipelineTessellationStateCreateInfo const *m_te_state;
 459     VkPipelineDynamicStateCreateInfo m_pd_state;
 460     vector<VkDynamicState> m_dynamic_state_enables;
 461     vector<VkViewport> m_viewports;
 462     vector<VkRect2D> m_scissors;
 463     VkDeviceObj *m_device;
 464     vector<VkPipelineShaderStageCreateInfo> m_shaderStages;
 465     vector<VkPipelineColorBlendAttachmentState> m_colorAttachments;
 466 };
 467
 468 #endif  // VKRENDERFRAMEWORK_H