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