sandy
/
PL286
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
18 GiB
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
PL286/external/vulkan-validation-layers/tests/vkrenderframework.h

429 lines
17 KiB
Raw Permalink Blame History

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