tests/vkrenderframework.h - platform/external/vulkan-validation-layers - Gitiles

 /*
  * Copyright (c) 2015-2016 The Khronos Group Inc.
  * Copyright (c) 2015-2016 Valve Corporation
  * Copyright (c) 2015-2016 LunarG, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
  */

 #ifndef VKRENDERFRAMEWORK_H
 #define VKRENDERFRAMEWORK_H

 #ifdef ANDROID
 #include "vktestframeworkandroid.h"
 class VkImageObj;
 #else
 #include "vktestframework.h"
 #endif

 #include <array>
 #include <map>
 #include <vector>

 using namespace std;

 class VkDeviceObj : public vk_testing::Device {
   public:
     VkDeviceObj(uint32_t id, VkPhysicalDevice obj);
     VkDeviceObj(uint32_t id, VkPhysicalDevice obj, std::vector<const char *> &extension_names,
                 VkPhysicalDeviceFeatures *features = nullptr);

     VkDevice device() { return handle(); }
     void get_device_queue();

     uint32_t id;
     VkPhysicalDeviceProperties props;
     std::vector<VkQueueFamilyProperties> queue_props;

     VkQueue m_queue;
 };

 class VkCommandBufferObj;
 class VkDepthStencilObj;

 class VkRenderFramework : public VkTestFramework {
   public:
     VkRenderFramework();
     ~VkRenderFramework();

     VkInstance instance() { return inst; }
     VkDevice device() { return m_device->device(); }
     VkPhysicalDevice gpu() { return objs[0]; }
     VkRenderPass renderPass() { return m_renderPass; }
     VkFramebuffer framebuffer() { return m_framebuffer; }
     void InitViewport(float width, float height);
     void InitViewport();
     void InitRenderTarget();
     void InitRenderTarget(uint32_t targets);
     void InitRenderTarget(VkImageView *dsBinding);
     void InitRenderTarget(uint32_t targets, VkImageView *dsBinding);
     void InitFramework();
     void InitFramework(std::vector<const char *> instance_layer_names, std::vector<const char *> instance_extension_names,
                        std::vector<const char *> device_extension_names, PFN_vkDebugReportCallbackEXT = NULL,
                        void *userData = NULL);

     void ShutdownFramework();
     void InitState(VkPhysicalDeviceFeatures *features = nullptr);

     const VkRenderPassBeginInfo &renderPassBeginInfo() const { return m_renderPassBeginInfo; }

   protected:
     VkApplicationInfo app_info;
     VkInstance inst;
     VkPhysicalDevice objs[16];
     uint32_t gpu_count;
     VkDeviceObj *m_device;
     VkCommandPool m_commandPool;
     VkCommandBufferObj *m_commandBuffer;
     VkRenderPass m_renderPass;
     VkFramebuffer m_framebuffer;
     std::vector<VkViewport> m_viewports;
     std::vector<VkRect2D> m_scissors;
     float m_lineWidth;
     float m_depthBiasConstantFactor;
     float m_depthBiasClamp;
     float m_depthBiasSlopeFactor;
     float m_blendConstants[4];
     float m_minDepthBounds;
     float m_maxDepthBounds;
     uint32_t m_compareMask;
     uint32_t m_writeMask;
     uint32_t m_reference;
     std::vector<VkClearValue> m_renderPassClearValues;
     VkRenderPassBeginInfo m_renderPassBeginInfo;
     vector<VkImageObj *> m_renderTargets;
     float m_width, m_height;
     VkFormat m_render_target_fmt;
     VkFormat m_depth_stencil_fmt;
     VkClearColorValue m_clear_color;
     bool m_clear_via_load_op;
     float m_depth_clear_color;
     uint32_t m_stencil_clear_color;
     VkDepthStencilObj *m_depthStencil;
     PFN_vkCreateDebugReportCallbackEXT m_CreateDebugReportCallback;
     PFN_vkDestroyDebugReportCallbackEXT m_DestroyDebugReportCallback;
     PFN_vkDebugReportMessageEXT m_DebugReportMessage;
     VkDebugReportCallbackEXT m_globalMsgCallback;
     VkDebugReportCallbackEXT m_devMsgCallback;
     std::vector<const char *> device_extension_names;

     /*
      * SetUp and TearDown are called by the Google Test framework
      * to initialize a test framework based on this class.
      */
     virtual void SetUp() {
         this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
         this->app_info.pApplicationName = "base";
         this->app_info.applicationVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
         this->app_info.apiVersion = VK_API_VERSION_1_0;

         InitFramework();
     }

     virtual void TearDown() { ShutdownFramework(); }
 };

 class VkDescriptorSetObj;
 class VkIndexBufferObj;
 class VkConstantBufferObj;
 class VkPipelineObj;
 class VkDescriptorSetObj;

 class VkCommandBufferObj : public vk_testing::CommandBuffer {
   public:
     VkCommandBufferObj(VkDeviceObj *device, VkCommandPool pool);
     VkCommandBuffer GetBufferHandle();
     VkResult BeginCommandBuffer();
     VkResult BeginCommandBuffer(VkCommandBufferBeginInfo *pInfo);
     VkResult EndCommandBuffer();
     void PipelineBarrier(VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages, VkDependencyFlags dependencyFlags,
                          uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount,
                          const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount,
                          const VkImageMemoryBarrier *pImageMemoryBarriers);
     void AddRenderTarget(VkImageObj *renderTarget);
     void AddDepthStencil();
     void ClearAllBuffers(VkClearColorValue clear_color, float depth_clear_color, uint32_t stencil_clear_color,
                          VkDepthStencilObj *depthStencilObj);
     void PrepareAttachments();
     void BindPipeline(VkPipelineObj &pipeline);
     void BindDescriptorSet(VkDescriptorSetObj &descriptorSet);
     void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding);
     void BindIndexBuffer(VkIndexBufferObj *indexBuffer, VkDeviceSize offset);
     void BeginRenderPass(const VkRenderPassBeginInfo &info);
     void EndRenderPass();
     void FillBuffer(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize fill_size, uint32_t data);
     void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
     void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
                      uint32_t firstInstance);
     void QueueCommandBuffer(bool checkSuccess = true);
     void QueueCommandBuffer(VkFence fence, bool checkSuccess = true);
     void SetViewport(uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports);
     void SetScissor(uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors);
     void SetLineWidth(float lineWidth);
     void SetDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
     void SetBlendConstants(const float blendConstants[4]);
     void SetDepthBounds(float minDepthBounds, float maxDepthBounds);
     void SetStencilReadMask(VkStencilFaceFlags faceMask, uint32_t compareMask);
     void SetStencilWriteMask(VkStencilFaceFlags faceMask, uint32_t writeMask);
     void SetStencilReference(VkStencilFaceFlags faceMask, uint32_t reference);
     void UpdateBuffer(VkBuffer buffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData);
     void CopyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
                    uint32_t regionCount, const VkImageCopy *pRegions);
     void ResolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
                       uint32_t regionCount, const VkImageResolve *pRegions);
     void ClearColorImage(VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount,
                          const VkImageSubresourceRange *pRanges);
     void ClearDepthStencilImage(VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pColor,
                                 uint32_t rangeCount, const VkImageSubresourceRange *pRanges);

   protected:
     VkDeviceObj *m_device;
     vector<VkImageObj *> m_renderTargets;
 };

 class VkConstantBufferObj : public vk_testing::Buffer {
   public:
     VkConstantBufferObj(VkDeviceObj *device,
                         VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
     VkConstantBufferObj(VkDeviceObj *device, int constantCount, int constantSize, const void *data,
                         VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
     ~VkConstantBufferObj();
     void BufferMemoryBarrier(VkFlags srcAccessMask = VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_SHADER_WRITE_BIT |
                                                      VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                                                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
                              VkFlags dstAccessMask = VK_ACCESS_HOST_READ_BIT | VK_ACCESS_INDIRECT_COMMAND_READ_BIT |
                                                      VK_ACCESS_INDEX_READ_BIT | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
                                                      VK_ACCESS_UNIFORM_READ_BIT | VK_ACCESS_SHADER_READ_BIT |
                                                      VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
                                                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_MEMORY_READ_BIT);

     void Bind(VkCommandBuffer commandBuffer, VkDeviceSize offset, uint32_t binding);

     VkDescriptorBufferInfo m_descriptorBufferInfo;

   protected:
     VkDeviceObj *m_device;
     vk_testing::BufferView m_bufferView;
     int m_numVertices;
     int m_stride;
     vk_testing::CommandPool *m_commandPool;
     VkCommandBufferObj *m_commandBuffer;
     vk_testing::Fence m_fence;
 };

 class VkIndexBufferObj : public VkConstantBufferObj {
   public:
     VkIndexBufferObj(VkDeviceObj *device);
     void CreateAndInitBuffer(int numIndexes, VkIndexType dataFormat, const void *data);
     void Bind(VkCommandBuffer commandBuffer, VkDeviceSize offset);
     VkIndexType GetIndexType();

   protected:
     VkIndexType m_indexType;
 };

 class VkRenderpassObj {
   public:
     VkRenderpassObj(VkDeviceObj *device);
     ~VkRenderpassObj();
     VkRenderPass handle() { return m_renderpass; }

   protected:
     VkRenderPass m_renderpass;
     VkDevice device;
 };

 class VkImageObj : public vk_testing::Image {
   public:
     VkImageObj(VkDeviceObj *dev);
     bool IsCompatible(VkFlags usage, VkFlags features);

   public:
     void init(uint32_t w, uint32_t h, VkFormat fmt, VkFlags usage, VkImageTiling tiling = VK_IMAGE_TILING_LINEAR,
               VkMemoryPropertyFlags reqs = 0);

     void init_no_layout(uint32_t w, uint32_t h, VkFormat fmt, VkFlags usage, VkImageTiling tiling = VK_IMAGE_TILING_LINEAR,
                         VkMemoryPropertyFlags reqs = 0);

     //    void clear( CommandBuffer*, uint32_t[4] );

     void layout(VkImageLayout layout) { m_descriptorImageInfo.imageLayout = layout; }

     VkDeviceMemory memory() const { return Image::memory().handle(); }

     void *MapMemory() { return Image::memory().map(); }

     void UnmapMemory() { Image::memory().unmap(); }

     void ImageMemoryBarrier(VkCommandBufferObj *cmd, VkImageAspectFlags aspect, VkFlags output_mask, VkFlags input_mask,
                             VkImageLayout image_layout);

     VkResult CopyImage(VkImageObj &src_image);

     VkImage image() const { return handle(); }

     VkImageView targetView(VkFormat format) {
         if (!m_targetView.initialized()) {
             VkImageViewCreateInfo createView = {};
             createView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
             createView.image = handle();
             createView.viewType = VK_IMAGE_VIEW_TYPE_2D;
             createView.format = format;
             createView.components.r = VK_COMPONENT_SWIZZLE_R;
             createView.components.g = VK_COMPONENT_SWIZZLE_G;
             createView.components.b = VK_COMPONENT_SWIZZLE_B;
             createView.components.a = VK_COMPONENT_SWIZZLE_A;
             createView.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
             createView.flags = 0;
             m_targetView.init(*m_device, createView);
         }
         return m_targetView.handle();
     }

     void SetLayout(VkCommandBufferObj *cmd_buf, VkImageAspectFlags aspect, VkImageLayout image_layout);
     void SetLayout(VkImageAspectFlags aspect, VkImageLayout image_layout);

     VkImageLayout layout() const { return m_descriptorImageInfo.imageLayout; }
     uint32_t width() const { return extent().width; }
     uint32_t height() const { return extent().height; }
     VkDeviceObj *device() const { return m_device; }

   protected:
     VkDeviceObj *m_device;

     vk_testing::ImageView m_targetView;
     VkDescriptorImageInfo m_descriptorImageInfo;
 };

 class VkTextureObj : public VkImageObj {
   public:
     VkTextureObj(VkDeviceObj *device, uint32_t *colors = NULL);

     VkDescriptorImageInfo m_imageInfo;

   protected:
     VkDeviceObj *m_device;
     vk_testing::ImageView m_textureView;
     VkDeviceSize m_rowPitch;
 };

 class VkDepthStencilObj : public VkImageObj {
   public:
     VkDepthStencilObj(VkDeviceObj *device);
     void Init(VkDeviceObj *device, int32_t width, int32_t height, VkFormat format,
               VkImageUsageFlags usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
     bool Initialized();
     VkImageView *BindInfo();

   protected:
     VkDeviceObj *m_device;
     bool m_initialized;
     vk_testing::ImageView m_imageView;
     VkFormat m_depth_stencil_fmt;
     VkImageView m_attachmentBindInfo;
 };

 class VkSamplerObj : public vk_testing::Sampler {
   public:
     VkSamplerObj(VkDeviceObj *device);

   protected:
     VkDeviceObj *m_device;
 };

 class VkDescriptorSetObj : public vk_testing::DescriptorPool {
   public:
     VkDescriptorSetObj(VkDeviceObj *device);
     ~VkDescriptorSetObj();

     int AppendDummy();
     int AppendBuffer(VkDescriptorType type, VkConstantBufferObj &constantBuffer);
     int AppendSamplerTexture(VkSamplerObj *sampler, VkTextureObj *texture);
     void CreateVKDescriptorSet(VkCommandBufferObj *commandBuffer);

     VkDescriptorSet GetDescriptorSetHandle() const;
     VkPipelineLayout GetPipelineLayout() const;
     int GetTypeCounts() { return m_type_counts.size(); }

   protected:
     VkDeviceObj *m_device;
     std::vector<VkDescriptorSetLayoutBinding> m_layout_bindings;
     std::map<VkDescriptorType, int> m_type_counts;
     int m_nextSlot;

     vector<VkDescriptorImageInfo> m_imageSamplerDescriptors;
     vector<VkWriteDescriptorSet> m_writes;

     vk_testing::DescriptorSetLayout m_layout;
     vk_testing::PipelineLayout m_pipeline_layout;
     vk_testing::DescriptorSet *m_set = NULL;
 };

 class VkShaderObj : public vk_testing::ShaderModule {
   public:
     VkShaderObj(VkDeviceObj *device, const char *shaderText, VkShaderStageFlagBits stage, VkRenderFramework *framework,
                 char const *name = "main");
     VkPipelineShaderStageCreateInfo GetStageCreateInfo() const;

   protected:
     VkPipelineShaderStageCreateInfo stage_info;
     VkShaderStageFlagBits m_stage;
     char const *m_name;
     VkDeviceObj *m_device;
 };

 class VkPipelineObj : public vk_testing::Pipeline {
   public:
     VkPipelineObj(VkDeviceObj *device);
     void AddShader(VkShaderObj *shaderObj);
     void AddVertexInputAttribs(VkVertexInputAttributeDescription *vi_attrib, uint32_t count);
     void AddVertexInputBindings(VkVertexInputBindingDescription *vi_binding, uint32_t count);
     void AddColorAttachment(uint32_t binding, const VkPipelineColorBlendAttachmentState *att);
     void MakeDynamic(VkDynamicState state);

     void AddColorAttachment() {
         VkPipelineColorBlendAttachmentState att = {};
         att.blendEnable = VK_FALSE;
         att.colorWriteMask = 0xf;
         AddColorAttachment(0, &att);
     }

     void SetDepthStencil(const VkPipelineDepthStencilStateCreateInfo *);
     void SetMSAA(const VkPipelineMultisampleStateCreateInfo *ms_state);
     void SetInputAssembly(const VkPipelineInputAssemblyStateCreateInfo *ia_state);
     void SetRasterization(const VkPipelineRasterizationStateCreateInfo *rs_state);
     void SetTessellation(const VkPipelineTessellationStateCreateInfo *te_state);
     void SetViewport(const vector<VkViewport> viewports);
     void SetScissor(const vector<VkRect2D> scissors);
     VkResult CreateVKPipeline(VkPipelineLayout layout, VkRenderPass render_pass);

   protected:
     VkPipelineVertexInputStateCreateInfo m_vi_state;
     VkPipelineInputAssemblyStateCreateInfo m_ia_state;
     VkPipelineRasterizationStateCreateInfo m_rs_state;
     VkPipelineColorBlendStateCreateInfo m_cb_state;
     VkPipelineDepthStencilStateCreateInfo const *m_ds_state;
     VkPipelineViewportStateCreateInfo m_vp_state;
     VkPipelineMultisampleStateCreateInfo m_ms_state;
     VkPipelineTessellationStateCreateInfo m_te_state;
     vector<VkDynamicState> m_dynamic_state_enables;
     vector<VkViewport> m_viewports;
     vector<VkRect2D> m_scissors;
     VkDeviceObj *m_device;
     vector<VkShaderObj *> m_shaderObjs;
     vector<int> m_vertexBufferBindings;
     vector<VkPipelineColorBlendAttachmentState> m_colorAttachments;
     int m_vertexBufferCount;
 };
 #endif // VKRENDERFRAMEWORK_H
	/*
	* Copyright (c) 2015-2016 The Khronos Group Inc.
	* Copyright (c) 2015-2016 Valve Corporation
	* Copyright (c) 2015-2016 LunarG, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	* Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
	*/

	#ifndef VKRENDERFRAMEWORK_H
	#define VKRENDERFRAMEWORK_H

	#ifdef ANDROID
	#include "vktestframeworkandroid.h"
	class VkImageObj;
	#else
	#include "vktestframework.h"
	#endif

	#include <array>
	#include <map>
	#include <vector>

	using namespace std;

	class VkDeviceObj : public vk_testing::Device {
	public:
	VkDeviceObj(uint32_t id, VkPhysicalDevice obj);
	VkDeviceObj(uint32_t id, VkPhysicalDevice obj, std::vector<const char *> &extension_names,
	VkPhysicalDeviceFeatures *features = nullptr);

	VkDevice device() { return handle(); }
	void get_device_queue();

	uint32_t id;
	VkPhysicalDeviceProperties props;
	std::vector<VkQueueFamilyProperties> queue_props;

	VkQueue m_queue;
	};

	class VkCommandBufferObj;
	class VkDepthStencilObj;

	class VkRenderFramework : public VkTestFramework {
	public:
	VkRenderFramework();
	~VkRenderFramework();

	VkInstance instance() { return inst; }
	VkDevice device() { return m_device->device(); }
	VkPhysicalDevice gpu() { return objs[0]; }
	VkRenderPass renderPass() { return m_renderPass; }
	VkFramebuffer framebuffer() { return m_framebuffer; }
	void InitViewport(float width, float height);
	void InitViewport();
	void InitRenderTarget();
	void InitRenderTarget(uint32_t targets);
	void InitRenderTarget(VkImageView *dsBinding);
	void InitRenderTarget(uint32_t targets, VkImageView *dsBinding);
	void InitFramework();
	void InitFramework(std::vector<const char > instance_layer_names, std::vector<const char > instance_extension_names,
	std::vector<const char *> device_extension_names, PFN_vkDebugReportCallbackEXT = NULL,
	void *userData = NULL);

	void ShutdownFramework();
	void InitState(VkPhysicalDeviceFeatures *features = nullptr);

	const VkRenderPassBeginInfo &renderPassBeginInfo() const { return m_renderPassBeginInfo; }

	protected:
	VkApplicationInfo app_info;
	VkInstance inst;
	VkPhysicalDevice objs[16];
	uint32_t gpu_count;
	VkDeviceObj *m_device;
	VkCommandPool m_commandPool;
	VkCommandBufferObj *m_commandBuffer;
	VkRenderPass m_renderPass;
	VkFramebuffer m_framebuffer;
	std::vector<VkViewport> m_viewports;
	std::vector<VkRect2D> m_scissors;
	float m_lineWidth;
	float m_depthBiasConstantFactor;
	float m_depthBiasClamp;
	float m_depthBiasSlopeFactor;
	float m_blendConstants[4];
	float m_minDepthBounds;
	float m_maxDepthBounds;
	uint32_t m_compareMask;
	uint32_t m_writeMask;
	uint32_t m_reference;
	std::vector<VkClearValue> m_renderPassClearValues;
	VkRenderPassBeginInfo m_renderPassBeginInfo;
	vector<VkImageObj *> m_renderTargets;
	float m_width, m_height;
	VkFormat m_render_target_fmt;
	VkFormat m_depth_stencil_fmt;
	VkClearColorValue m_clear_color;
	bool m_clear_via_load_op;
	float m_depth_clear_color;
	uint32_t m_stencil_clear_color;
	VkDepthStencilObj *m_depthStencil;
	PFN_vkCreateDebugReportCallbackEXT m_CreateDebugReportCallback;
	PFN_vkDestroyDebugReportCallbackEXT m_DestroyDebugReportCallback;
	PFN_vkDebugReportMessageEXT m_DebugReportMessage;
	VkDebugReportCallbackEXT m_globalMsgCallback;
	VkDebugReportCallbackEXT m_devMsgCallback;
	std::vector<const char *> device_extension_names;

	/*
	* SetUp and TearDown are called by the Google Test framework
	* to initialize a test framework based on this class.
	*/
	virtual void SetUp() {
	this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	this->app_info.pNext = NULL;
	this->app_info.pApplicationName = "base";
	this->app_info.applicationVersion = 1;
	this->app_info.pEngineName = "unittest";
	this->app_info.engineVersion = 1;
	this->app_info.apiVersion = VK_API_VERSION_1_0;

	InitFramework();
	}

	virtual void TearDown() { ShutdownFramework(); }
	};

	class VkDescriptorSetObj;
	class VkIndexBufferObj;
	class VkConstantBufferObj;
	class VkPipelineObj;
	class VkDescriptorSetObj;

	class VkCommandBufferObj : public vk_testing::CommandBuffer {
	public:
	VkCommandBufferObj(VkDeviceObj *device, VkCommandPool pool);
	VkCommandBuffer GetBufferHandle();
	VkResult BeginCommandBuffer();
	VkResult BeginCommandBuffer(VkCommandBufferBeginInfo *pInfo);
	VkResult EndCommandBuffer();
	void PipelineBarrier(VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages, VkDependencyFlags dependencyFlags,
	uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount,
	const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount,
	const VkImageMemoryBarrier *pImageMemoryBarriers);
	void AddRenderTarget(VkImageObj *renderTarget);
	void AddDepthStencil();
	void ClearAllBuffers(VkClearColorValue clear_color, float depth_clear_color, uint32_t stencil_clear_color,
	VkDepthStencilObj *depthStencilObj);
	void PrepareAttachments();
	void BindPipeline(VkPipelineObj &pipeline);
	void BindDescriptorSet(VkDescriptorSetObj &descriptorSet);
	void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding);
	void BindIndexBuffer(VkIndexBufferObj *indexBuffer, VkDeviceSize offset);
	void BeginRenderPass(const VkRenderPassBeginInfo &info);
	void EndRenderPass();
	void FillBuffer(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize fill_size, uint32_t data);
	void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
	void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
	uint32_t firstInstance);
	void QueueCommandBuffer(bool checkSuccess = true);
	void QueueCommandBuffer(VkFence fence, bool checkSuccess = true);
	void SetViewport(uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports);
	void SetScissor(uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors);
	void SetLineWidth(float lineWidth);
	void SetDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
	void SetBlendConstants(const float blendConstants[4]);
	void SetDepthBounds(float minDepthBounds, float maxDepthBounds);
	void SetStencilReadMask(VkStencilFaceFlags faceMask, uint32_t compareMask);
	void SetStencilWriteMask(VkStencilFaceFlags faceMask, uint32_t writeMask);
	void SetStencilReference(VkStencilFaceFlags faceMask, uint32_t reference);
	void UpdateBuffer(VkBuffer buffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData);
	void CopyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
	uint32_t regionCount, const VkImageCopy *pRegions);
	void ResolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
	uint32_t regionCount, const VkImageResolve *pRegions);
	void ClearColorImage(VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount,
	const VkImageSubresourceRange *pRanges);
	void ClearDepthStencilImage(VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pColor,
	uint32_t rangeCount, const VkImageSubresourceRange *pRanges);

	protected:
	VkDeviceObj *m_device;
	vector<VkImageObj *> m_renderTargets;
	};

	class VkConstantBufferObj : public vk_testing::Buffer {
	public:
	VkConstantBufferObj(VkDeviceObj *device,
	VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT \| VK_BUFFER_USAGE_TRANSFER_DST_BIT);
	VkConstantBufferObj(VkDeviceObj device, int constantCount, int constantSize, const void data,
	VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT \| VK_BUFFER_USAGE_TRANSFER_DST_BIT);
	~VkConstantBufferObj();
	void BufferMemoryBarrier(VkFlags srcAccessMask = VK_ACCESS_HOST_WRITE_BIT \| VK_ACCESS_SHADER_WRITE_BIT \|
	VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT \|
	VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT \| VK_ACCESS_TRANSFER_WRITE_BIT,
	VkFlags dstAccessMask = VK_ACCESS_HOST_READ_BIT \| VK_ACCESS_INDIRECT_COMMAND_READ_BIT \|
	VK_ACCESS_INDEX_READ_BIT \| VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT \|
	VK_ACCESS_UNIFORM_READ_BIT \| VK_ACCESS_SHADER_READ_BIT \|
	VK_ACCESS_COLOR_ATTACHMENT_READ_BIT \|
	VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT \| VK_ACCESS_MEMORY_READ_BIT);

	void Bind(VkCommandBuffer commandBuffer, VkDeviceSize offset, uint32_t binding);

	VkDescriptorBufferInfo m_descriptorBufferInfo;

	protected:
	VkDeviceObj *m_device;
	vk_testing::BufferView m_bufferView;
	int m_numVertices;
	int m_stride;
	vk_testing::CommandPool *m_commandPool;
	VkCommandBufferObj *m_commandBuffer;
	vk_testing::Fence m_fence;
	};

	class VkIndexBufferObj : public VkConstantBufferObj {
	public:
	VkIndexBufferObj(VkDeviceObj *device);
	void CreateAndInitBuffer(int numIndexes, VkIndexType dataFormat, const void *data);
	void Bind(VkCommandBuffer commandBuffer, VkDeviceSize offset);
	VkIndexType GetIndexType();

	protected:
	VkIndexType m_indexType;
	};

	class VkRenderpassObj {
	public:
	VkRenderpassObj(VkDeviceObj *device);
	~VkRenderpassObj();
	VkRenderPass handle() { return m_renderpass; }

	protected:
	VkRenderPass m_renderpass;
	VkDevice device;
	};

	class VkImageObj : public vk_testing::Image {
	public:
	VkImageObj(VkDeviceObj *dev);
	bool IsCompatible(VkFlags usage, VkFlags features);

	public:
	void init(uint32_t w, uint32_t h, VkFormat fmt, VkFlags usage, VkImageTiling tiling = VK_IMAGE_TILING_LINEAR,
	VkMemoryPropertyFlags reqs = 0);

	void init_no_layout(uint32_t w, uint32_t h, VkFormat fmt, VkFlags usage, VkImageTiling tiling = VK_IMAGE_TILING_LINEAR,
	VkMemoryPropertyFlags reqs = 0);

	// void clear( CommandBuffer*, uint32_t[4] );

	void layout(VkImageLayout layout) { m_descriptorImageInfo.imageLayout = layout; }

	VkDeviceMemory memory() const { return Image::memory().handle(); }

	void *MapMemory() { return Image::memory().map(); }

	void UnmapMemory() { Image::memory().unmap(); }

	void ImageMemoryBarrier(VkCommandBufferObj *cmd, VkImageAspectFlags aspect, VkFlags output_mask, VkFlags input_mask,
	VkImageLayout image_layout);

	VkResult CopyImage(VkImageObj &src_image);

	VkImage image() const { return handle(); }

	VkImageView targetView(VkFormat format) {
	if (!m_targetView.initialized()) {
	VkImageViewCreateInfo createView = {};
	createView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
	createView.image = handle();
	createView.viewType = VK_IMAGE_VIEW_TYPE_2D;
	createView.format = format;
	createView.components.r = VK_COMPONENT_SWIZZLE_R;
	createView.components.g = VK_COMPONENT_SWIZZLE_G;
	createView.components.b = VK_COMPONENT_SWIZZLE_B;
	createView.components.a = VK_COMPONENT_SWIZZLE_A;
	createView.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
	createView.flags = 0;
	m_targetView.init(*m_device, createView);
	}
	return m_targetView.handle();
	}

	void SetLayout(VkCommandBufferObj *cmd_buf, VkImageAspectFlags aspect, VkImageLayout image_layout);
	void SetLayout(VkImageAspectFlags aspect, VkImageLayout image_layout);

	VkImageLayout layout() const { return m_descriptorImageInfo.imageLayout; }
	uint32_t width() const { return extent().width; }
	uint32_t height() const { return extent().height; }
	VkDeviceObj *device() const { return m_device; }

	protected:
	VkDeviceObj *m_device;

	vk_testing::ImageView m_targetView;
	VkDescriptorImageInfo m_descriptorImageInfo;
	};

	class VkTextureObj : public VkImageObj {
	public:
	VkTextureObj(VkDeviceObj device, uint32_t colors = NULL);

	VkDescriptorImageInfo m_imageInfo;

	protected:
	VkDeviceObj *m_device;
	vk_testing::ImageView m_textureView;
	VkDeviceSize m_rowPitch;
	};

	class VkDepthStencilObj : public VkImageObj {
	public:
	VkDepthStencilObj(VkDeviceObj *device);
	void Init(VkDeviceObj *device, int32_t width, int32_t height, VkFormat format,
	VkImageUsageFlags usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
	bool Initialized();
	VkImageView *BindInfo();

	protected:
	VkDeviceObj *m_device;
	bool m_initialized;
	vk_testing::ImageView m_imageView;
	VkFormat m_depth_stencil_fmt;
	VkImageView m_attachmentBindInfo;
	};

	class VkSamplerObj : public vk_testing::Sampler {
	public:
	VkSamplerObj(VkDeviceObj *device);

	protected:
	VkDeviceObj *m_device;
	};

	class VkDescriptorSetObj : public vk_testing::DescriptorPool {
	public:
	VkDescriptorSetObj(VkDeviceObj *device);
	~VkDescriptorSetObj();

	int AppendDummy();
	int AppendBuffer(VkDescriptorType type, VkConstantBufferObj &constantBuffer);
	int AppendSamplerTexture(VkSamplerObj sampler, VkTextureObj texture);
	void CreateVKDescriptorSet(VkCommandBufferObj *commandBuffer);

	VkDescriptorSet GetDescriptorSetHandle() const;
	VkPipelineLayout GetPipelineLayout() const;
	int GetTypeCounts() { return m_type_counts.size(); }

	protected:
	VkDeviceObj *m_device;
	std::vector<VkDescriptorSetLayoutBinding> m_layout_bindings;
	std::map<VkDescriptorType, int> m_type_counts;
	int m_nextSlot;

	vector<VkDescriptorImageInfo> m_imageSamplerDescriptors;
	vector<VkWriteDescriptorSet> m_writes;

	vk_testing::DescriptorSetLayout m_layout;
	vk_testing::PipelineLayout m_pipeline_layout;
	vk_testing::DescriptorSet *m_set = NULL;
	};

	class VkShaderObj : public vk_testing::ShaderModule {
	public:
	VkShaderObj(VkDeviceObj device, const char shaderText, VkShaderStageFlagBits stage, VkRenderFramework *framework,
	char const *name = "main");
	VkPipelineShaderStageCreateInfo GetStageCreateInfo() const;

	protected:
	VkPipelineShaderStageCreateInfo stage_info;
	VkShaderStageFlagBits m_stage;
	char const *m_name;
	VkDeviceObj *m_device;
	};

	class VkPipelineObj : public vk_testing::Pipeline {
	public:
	VkPipelineObj(VkDeviceObj *device);
	void AddShader(VkShaderObj *shaderObj);
	void AddVertexInputAttribs(VkVertexInputAttributeDescription *vi_attrib, uint32_t count);
	void AddVertexInputBindings(VkVertexInputBindingDescription *vi_binding, uint32_t count);
	void AddColorAttachment(uint32_t binding, const VkPipelineColorBlendAttachmentState *att);
	void MakeDynamic(VkDynamicState state);

	void AddColorAttachment() {
	VkPipelineColorBlendAttachmentState att = {};
	att.blendEnable = VK_FALSE;
	att.colorWriteMask = 0xf;
	AddColorAttachment(0, &att);
	}

	void SetDepthStencil(const VkPipelineDepthStencilStateCreateInfo *);
	void SetMSAA(const VkPipelineMultisampleStateCreateInfo *ms_state);
	void SetInputAssembly(const VkPipelineInputAssemblyStateCreateInfo *ia_state);
	void SetRasterization(const VkPipelineRasterizationStateCreateInfo *rs_state);
	void SetTessellation(const VkPipelineTessellationStateCreateInfo *te_state);
	void SetViewport(const vector<VkViewport> viewports);
	void SetScissor(const vector<VkRect2D> scissors);
	VkResult CreateVKPipeline(VkPipelineLayout layout, VkRenderPass render_pass);

	protected:
	VkPipelineVertexInputStateCreateInfo m_vi_state;
	VkPipelineInputAssemblyStateCreateInfo m_ia_state;
	VkPipelineRasterizationStateCreateInfo m_rs_state;
	VkPipelineColorBlendStateCreateInfo m_cb_state;
	VkPipelineDepthStencilStateCreateInfo const *m_ds_state;
	VkPipelineViewportStateCreateInfo m_vp_state;
	VkPipelineMultisampleStateCreateInfo m_ms_state;
	VkPipelineTessellationStateCreateInfo m_te_state;
	vector<VkDynamicState> m_dynamic_state_enables;
	vector<VkViewport> m_viewports;
	vector<VkRect2D> m_scissors;
	VkDeviceObj *m_device;
	vector<VkShaderObj *> m_shaderObjs;
	vector<int> m_vertexBufferBindings;
	vector<VkPipelineColorBlendAttachmentState> m_colorAttachments;
	int m_vertexBufferCount;
	};
	#endif // VKRENDERFRAMEWORK_H