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 <map>
 #include <vector>
 #include <array>

 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 *> &layers,
                 std::vector<const char *> &extension_names);

     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 *> device_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();

     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;

     /*
      * 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 uint32_t *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);

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

 class VkConstantBufferObj : public vk_testing::Buffer {
   public:
     VkConstantBufferObj(VkDeviceObj *device);
     VkConstantBufferObj(VkDeviceObj *device, int constantCount,
                         int constantSize, const void *data);
     ~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 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 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,
                                unsigned count);
     void AddVertexInputBindings(VkVertexInputBindingDescription *vi_binding,
                                 unsigned 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 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;
 };
 class cMemoryBuffer {
 public:
     cMemoryBuffer(VkDeviceObj *aVulkanDevice, VkBufferUsageFlags aBufferUsage, VkDeviceSize &aBufferByteCount, const float *aClientData) :
        AllocateCurrent(false),
        BoundCurrent(false),
        CreateCurrent(false),
        VulkanDevice(aVulkanDevice->device()) {

         VkBufferCreateInfo buffer_create_info = {};
         buffer_create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
         buffer_create_info.size = aBufferByteCount;
         buffer_create_info.usage = aBufferUsage;

         VkResult returnValue = vkCreateBuffer(VulkanDevice, &buffer_create_info, nullptr, &VulkanBuffer);
         assert(!returnValue);
         CreateCurrent = true;

         VkMemoryRequirements memory_requirements;
         vkGetBufferMemoryRequirements(VulkanDevice, VulkanBuffer, &memory_requirements);

         VkMemoryAllocateInfo memory_allocate_info = {};
         memory_allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
         memory_allocate_info.allocationSize = memory_requirements.size;
         bool pass = aVulkanDevice->phy().set_memory_type(memory_requirements.memoryTypeBits, &memory_allocate_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
         if (!pass) {
             vkDestroyBuffer(VulkanDevice, VulkanBuffer, nullptr);
             return;
         }

         returnValue = vkAllocateMemory(VulkanDevice, &memory_allocate_info, NULL, &VulkanMemory);
         assert(!returnValue);
         AllocateCurrent = true;

         void *mappedMemory;
         returnValue = vkMapMemory(VulkanDevice, VulkanMemory, 0, memory_allocate_info.allocationSize, 0, &mappedMemory);
         assert(!returnValue);

         memcpy(mappedMemory, aClientData, static_cast<size_t>(aBufferByteCount));

         vkUnmapMemory(VulkanDevice, VulkanMemory);

         returnValue = vkBindBufferMemory(VulkanDevice, VulkanBuffer, VulkanMemory, 0);
         assert(!returnValue);
         BoundCurrent = true;
     }

     ~cMemoryBuffer() {
         if (CreateCurrent) {
             vkDestroyBuffer(VulkanDevice, VulkanBuffer, nullptr);
         }
         if (AllocateCurrent) {
             vkFreeMemory(VulkanDevice, VulkanMemory, nullptr);
         }
     }

     const VkBuffer &GetBuffer() {
         return VulkanBuffer;
     }

 protected:
     bool AllocateCurrent;
     bool BoundCurrent;
     bool CreateCurrent;

     VkBuffer VulkanBuffer;
     VkDevice VulkanDevice;
     VkDeviceMemory VulkanMemory;

 };

 class cVertices {
 public:
     cVertices(VkDeviceObj *aVulkanDevice, unsigned aAttributeCount, unsigned aBindingCount, unsigned aByteStride, VkDeviceSize aVertexCount, const float *aVerticies) :
        BoundCurrent(false),
        AttributeCount(aAttributeCount),
        BindingCount(aBindingCount),
        BindId(BindIdGenerator),
        PipelineVertexInputStateCreateInfo(),
        VulkanDevice(aVulkanDevice->device()),
        VulkanMemoryBuffer(aVulkanDevice, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, aVertexCount, aVerticies) {
         BindIdGenerator++; // NB: This can wrap w/misuse
         VertexInputAttributeDescription = new VkVertexInputAttributeDescription[AttributeCount];
         VertexInputBindingDescription = new VkVertexInputBindingDescription[BindingCount];

         PipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions = VertexInputAttributeDescription;
         PipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount = AttributeCount;
         PipelineVertexInputStateCreateInfo.pVertexBindingDescriptions = VertexInputBindingDescription;
         PipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount = BindingCount;
         PipelineVertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;

         unsigned i = 0;
         do {
             VertexInputAttributeDescription[i].binding = BindId;
             VertexInputAttributeDescription[i].location = i;
             VertexInputAttributeDescription[i].format = VK_FORMAT_R32G32B32_SFLOAT;
             VertexInputAttributeDescription[i].offset = sizeof(float) * aByteStride;
             i++;
         } while (AttributeCount < i);

         i = 0;
         do {
             VertexInputBindingDescription[i].binding = BindId;
             VertexInputBindingDescription[i].stride = aByteStride;
             VertexInputBindingDescription[i].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
             i++;
         } while (BindingCount < i);
     }

     ~cVertices() {
         if (VertexInputAttributeDescription) {
             delete[] VertexInputAttributeDescription;
         }
         if (VertexInputBindingDescription) {
             delete[] VertexInputBindingDescription;
         }
     }

     void BindVertexBuffers(VkCommandBuffer aCommandBuffer, unsigned aOffsetCount = 0, VkDeviceSize *aOffsetList = nullptr) {
         VkDeviceSize *offsetList;
         unsigned offsetCount;

         if (aOffsetCount) {
             offsetList = aOffsetList;
             offsetCount = aOffsetCount;
         }
         else {
             offsetList = new VkDeviceSize[1]();
             offsetCount = 1;
         }

         vkCmdBindVertexBuffers(aCommandBuffer, BindId, offsetCount, &VulkanMemoryBuffer.GetBuffer(), offsetList);
         BoundCurrent = true;

         if (!aOffsetCount) {
             delete [] offsetList;
         }
     }

     void AddVertexInputToPipe(VkPipelineObj &aPipelineObj) {
         aPipelineObj.AddVertexInputAttribs(VertexInputAttributeDescription, AttributeCount);
         aPipelineObj.AddVertexInputBindings(VertexInputBindingDescription, BindingCount);
     }

 protected:
     static unsigned BindIdGenerator;

     bool BoundCurrent;
     unsigned AttributeCount;
     unsigned BindingCount;
     uint32_t BindId;
     VkDeviceMemory DeviceMemory;

     VkPipelineVertexInputStateCreateInfo PipelineVertexInputStateCreateInfo;
     VkVertexInputAttributeDescription *VertexInputAttributeDescription;
     VkVertexInputBindingDescription *VertexInputBindingDescription;
     VkDevice VulkanDevice;
     cMemoryBuffer VulkanMemoryBuffer;
 };


 #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 <map>
	#include <vector>
	#include <array>

	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 *> &layers,
	std::vector<const char *> &extension_names);

	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 *> device_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();

	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;

	/*
	* 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 uint32_t *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);

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

	class VkConstantBufferObj : public vk_testing::Buffer {
	public:
	VkConstantBufferObj(VkDeviceObj *device);
	VkConstantBufferObj(VkDeviceObj *device, int constantCount,
	int constantSize, const void *data);
	~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 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 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,
	unsigned count);
	void AddVertexInputBindings(VkVertexInputBindingDescription *vi_binding,
	unsigned 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 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;
	};
	class cMemoryBuffer {
	public:
	cMemoryBuffer(VkDeviceObj aVulkanDevice, VkBufferUsageFlags aBufferUsage, VkDeviceSize &aBufferByteCount, const float aClientData) :
	AllocateCurrent(false),
	BoundCurrent(false),
	CreateCurrent(false),
	VulkanDevice(aVulkanDevice->device()) {

	VkBufferCreateInfo buffer_create_info = {};
	buffer_create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
	buffer_create_info.size = aBufferByteCount;
	buffer_create_info.usage = aBufferUsage;

	VkResult returnValue = vkCreateBuffer(VulkanDevice, &buffer_create_info, nullptr, &VulkanBuffer);
	assert(!returnValue);
	CreateCurrent = true;

	VkMemoryRequirements memory_requirements;
	vkGetBufferMemoryRequirements(VulkanDevice, VulkanBuffer, &memory_requirements);

	VkMemoryAllocateInfo memory_allocate_info = {};
	memory_allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	memory_allocate_info.allocationSize = memory_requirements.size;
	bool pass = aVulkanDevice->phy().set_memory_type(memory_requirements.memoryTypeBits, &memory_allocate_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
	if (!pass) {
	vkDestroyBuffer(VulkanDevice, VulkanBuffer, nullptr);
	return;
	}

	returnValue = vkAllocateMemory(VulkanDevice, &memory_allocate_info, NULL, &VulkanMemory);
	assert(!returnValue);
	AllocateCurrent = true;

	void *mappedMemory;
	returnValue = vkMapMemory(VulkanDevice, VulkanMemory, 0, memory_allocate_info.allocationSize, 0, &mappedMemory);
	assert(!returnValue);

	memcpy(mappedMemory, aClientData, static_cast<size_t>(aBufferByteCount));

	vkUnmapMemory(VulkanDevice, VulkanMemory);

	returnValue = vkBindBufferMemory(VulkanDevice, VulkanBuffer, VulkanMemory, 0);
	assert(!returnValue);
	BoundCurrent = true;
	}

	~cMemoryBuffer() {
	if (CreateCurrent) {
	vkDestroyBuffer(VulkanDevice, VulkanBuffer, nullptr);
	}
	if (AllocateCurrent) {
	vkFreeMemory(VulkanDevice, VulkanMemory, nullptr);
	}
	}

	const VkBuffer &GetBuffer() {
	return VulkanBuffer;
	}

	protected:
	bool AllocateCurrent;
	bool BoundCurrent;
	bool CreateCurrent;

	VkBuffer VulkanBuffer;
	VkDevice VulkanDevice;
	VkDeviceMemory VulkanMemory;

	};

	class cVertices {
	public:
	cVertices(VkDeviceObj aVulkanDevice, unsigned aAttributeCount, unsigned aBindingCount, unsigned aByteStride, VkDeviceSize aVertexCount, const float aVerticies) :
	BoundCurrent(false),
	AttributeCount(aAttributeCount),
	BindingCount(aBindingCount),
	BindId(BindIdGenerator),
	PipelineVertexInputStateCreateInfo(),
	VulkanDevice(aVulkanDevice->device()),
	VulkanMemoryBuffer(aVulkanDevice, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, aVertexCount, aVerticies) {
	BindIdGenerator++; // NB: This can wrap w/misuse
	VertexInputAttributeDescription = new VkVertexInputAttributeDescription[AttributeCount];
	VertexInputBindingDescription = new VkVertexInputBindingDescription[BindingCount];

	PipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions = VertexInputAttributeDescription;
	PipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount = AttributeCount;
	PipelineVertexInputStateCreateInfo.pVertexBindingDescriptions = VertexInputBindingDescription;
	PipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount = BindingCount;
	PipelineVertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;

	unsigned i = 0;
	do {
	VertexInputAttributeDescription[i].binding = BindId;
	VertexInputAttributeDescription[i].location = i;
	VertexInputAttributeDescription[i].format = VK_FORMAT_R32G32B32_SFLOAT;
	VertexInputAttributeDescription[i].offset = sizeof(float) * aByteStride;
	i++;
	} while (AttributeCount < i);

	i = 0;
	do {
	VertexInputBindingDescription[i].binding = BindId;
	VertexInputBindingDescription[i].stride = aByteStride;
	VertexInputBindingDescription[i].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
	i++;
	} while (BindingCount < i);
	}

	~cVertices() {
	if (VertexInputAttributeDescription) {
	delete[] VertexInputAttributeDescription;
	}
	if (VertexInputBindingDescription) {
	delete[] VertexInputBindingDescription;
	}
	}

	void BindVertexBuffers(VkCommandBuffer aCommandBuffer, unsigned aOffsetCount = 0, VkDeviceSize *aOffsetList = nullptr) {
	VkDeviceSize *offsetList;
	unsigned offsetCount;

	if (aOffsetCount) {
	offsetList = aOffsetList;
	offsetCount = aOffsetCount;
	}
	else {
	offsetList = new VkDeviceSize[1]();
	offsetCount = 1;
	}

	vkCmdBindVertexBuffers(aCommandBuffer, BindId, offsetCount, &VulkanMemoryBuffer.GetBuffer(), offsetList);
	BoundCurrent = true;

	if (!aOffsetCount) {
	delete [] offsetList;
	}
	}

	void AddVertexInputToPipe(VkPipelineObj &aPipelineObj) {
	aPipelineObj.AddVertexInputAttribs(VertexInputAttributeDescription, AttributeCount);
	aPipelineObj.AddVertexInputBindings(VertexInputBindingDescription, BindingCount);
	}

	protected:
	static unsigned BindIdGenerator;

	bool BoundCurrent;
	unsigned AttributeCount;
	unsigned BindingCount;
	uint32_t BindId;
	VkDeviceMemory DeviceMemory;

	VkPipelineVertexInputStateCreateInfo PipelineVertexInputStateCreateInfo;
	VkVertexInputAttributeDescription *VertexInputAttributeDescription;
	VkVertexInputBindingDescription *VertexInputBindingDescription;
	VkDevice VulkanDevice;
	cMemoryBuffer VulkanMemoryBuffer;
	};


	#endif // VKRENDERFRAMEWORK_H