blob: 02b349879034aef53c040c61ad4d0a6da76544bc [file] [log] [blame]
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -06001// VK tests
Chia-I Wuf1e2e992014-12-27 14:12:52 +08002//
3// Copyright (C) 2014 LunarG, Inc.
4//
5// Permission is hereby granted, free of charge, to any person obtaining a
6// copy of this software and associated documentation files (the "Software"),
7// to deal in the Software without restriction, including without limitation
8// the rights to use, copy, modify, merge, publish, distribute, sublicense,
9// and/or sell copies of the Software, and to permit persons to whom the
10// Software is furnished to do so, subject to the following conditions:
11//
12// The above copyright notice and this permission notice shall be included
13// in all copies or substantial portions of the Software.
14//
15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21// DEALINGS IN THE SOFTWARE.
22
23#include <iostream>
24#include <string.h> // memset(), memcmp()
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -060025#include <assert.h>
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -060026#include "vktestbinding.h"
Chia-I Wuf1e2e992014-12-27 14:12:52 +080027
28namespace {
Chia-I Wuf1e2e992014-12-27 14:12:52 +080029
Chia-I Wuf8f074f2015-07-03 10:58:57 +080030#define NON_DISPATCHABLE_HANDLE_INIT(create_func, dev, ...) \
31 do { \
32 handle_type handle; \
33 if (EXPECT(create_func(dev.handle(), __VA_ARGS__, &handle) == VK_SUCCESS)) \
34 NonDispHandle::init(dev.handle(), handle); \
35 } while (0)
36
Chia-I Wud9e8e822015-07-03 11:45:55 +080037#define NON_DISPATCHABLE_HANDLE_DTOR(cls, destroy_func, ...) \
38 cls::~cls() \
39 { \
40 if (initialized()) \
41 EXPECT(destroy_func(device(), __VA_ARGS__, handle()) == VK_SUCCESS); \
42 }
43
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -060044#define DERIVED_OBJECT_TYPE_INIT(create_func, dev, vk_object_type, ...) \
45 do { \
46 obj_type obj; \
47 dev_ = &dev; \
Chia-I Wuf368b602015-07-03 10:41:20 +080048 if (EXPECT(create_func(dev.handle(), __VA_ARGS__, &obj) == VK_SUCCESS)) \
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -060049 base_type::init(obj, vk_object_type); \
Mike Stroyanb050c682015-04-17 12:36:38 -060050 } while (0)
51
Chia-I Wuf1e2e992014-12-27 14:12:52 +080052#define STRINGIFY(x) #x
53#define EXPECT(expr) ((expr) ? true : expect_failure(STRINGIFY(expr), __FILE__, __LINE__, __FUNCTION__))
Mark Lobodzinski40f7f402015-04-16 11:44:05 -050054
Chia-I Wuf1e2e992014-12-27 14:12:52 +080055
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -060056vk_testing::ErrorCallback error_callback;
Chia-I Wuf1e2e992014-12-27 14:12:52 +080057
58bool expect_failure(const char *expr, const char *file, unsigned int line, const char *function)
59{
60 if (error_callback) {
61 error_callback(expr, file, line, function);
62 } else {
63 std::cerr << file << ":" << line << ": " << function <<
64 ": Expectation `" << expr << "' failed.\n";
65 }
66
67 return false;
68}
69
70template<class T, class S>
Chia-I Wud9e8e822015-07-03 11:45:55 +080071std::vector<T> make_handles(const std::vector<S> &v)
72{
73 std::vector<T> handles;
74 handles.reserve(v.size());
75 for (typename std::vector<S>::const_iterator it = v.begin(); it != v.end(); it++)
76 handles.push_back((*it)->handle());
77 return handles;
78}
79
80template<class T, class S>
Chia-I Wuf1e2e992014-12-27 14:12:52 +080081std::vector<T> make_objects(const std::vector<S> &v)
82{
83 std::vector<T> objs;
84 objs.reserve(v.size());
85 for (typename std::vector<S>::const_iterator it = v.begin(); it != v.end(); it++)
86 objs.push_back((*it)->obj());
87 return objs;
88}
89
90template<typename T>
Tony Barbour59a47322015-06-24 16:06:58 -060091std::vector<T> get_memory_reqs(VkDevice device, VkObjectType obj_type, VkObject obj, size_t min_elems)
Chia-I Wuf1e2e992014-12-27 14:12:52 +080092{
93 std::vector<T> info;
Tony Barbour59a47322015-06-24 16:06:58 -060094
95 info.resize((min_elems > 0)?min_elems:1);
96 if (!EXPECT(vkGetObjectMemoryRequirements(device, obj_type, obj, &info[0]) == VK_SUCCESS))
97 info.clear();
Chia-I Wuf1e2e992014-12-27 14:12:52 +080098
99 if (info.size() < min_elems)
100 info.resize(min_elems);
101
102 return info;
103}
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800104} // namespace
105
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600106namespace vk_testing {
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800107
108void set_error_callback(ErrorCallback callback)
109{
110 error_callback = callback;
111}
112
Chia-I Wu999f0482015-07-03 10:32:05 +0800113VkPhysicalDeviceProperties PhysicalDevice::properties() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800114{
Tony Barbour59a47322015-06-24 16:06:58 -0600115 VkPhysicalDeviceProperties info;
116
Chia-I Wu999f0482015-07-03 10:32:05 +0800117 EXPECT(vkGetPhysicalDeviceProperties(handle(), &info) == VK_SUCCESS);
Tony Barbour59a47322015-06-24 16:06:58 -0600118
119 return info;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800120}
121
Chia-I Wu999f0482015-07-03 10:32:05 +0800122VkPhysicalDevicePerformance PhysicalDevice::performance() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800123{
Tony Barbour59a47322015-06-24 16:06:58 -0600124 VkPhysicalDevicePerformance info;
125
Chia-I Wu999f0482015-07-03 10:32:05 +0800126 EXPECT(vkGetPhysicalDevicePerformance(handle(), &info) == VK_SUCCESS);
Tony Barbour59a47322015-06-24 16:06:58 -0600127
128 return info;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800129}
130
Chia-I Wu999f0482015-07-03 10:32:05 +0800131std::vector<VkPhysicalDeviceQueueProperties> PhysicalDevice::queue_properties() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800132{
Tony Barbour59a47322015-06-24 16:06:58 -0600133 std::vector<VkPhysicalDeviceQueueProperties> info;
134 uint32_t count;
135
Chia-I Wu999f0482015-07-03 10:32:05 +0800136 if (EXPECT(vkGetPhysicalDeviceQueueCount(handle(), &count) == VK_SUCCESS)) {
Tony Barbour59a47322015-06-24 16:06:58 -0600137 info.resize(count);
Chia-I Wu999f0482015-07-03 10:32:05 +0800138 if (!EXPECT(vkGetPhysicalDeviceQueueProperties(handle(), count, &info[0]) == VK_SUCCESS))
Tony Barbour59a47322015-06-24 16:06:58 -0600139 info.clear();
140 }
141
142 return info;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800143}
144
Chia-I Wu999f0482015-07-03 10:32:05 +0800145VkPhysicalDeviceMemoryProperties PhysicalDevice::memory_properties() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800146{
Tony Barbour59a47322015-06-24 16:06:58 -0600147 VkPhysicalDeviceMemoryProperties info;
148
Chia-I Wu999f0482015-07-03 10:32:05 +0800149 EXPECT(vkGetPhysicalDeviceMemoryProperties(handle(), &info) == VK_SUCCESS);
Tony Barbour59a47322015-06-24 16:06:58 -0600150
Mark Lobodzinskib3fbcd92015-07-02 16:49:40 -0600151
Tony Barbour59a47322015-06-24 16:06:58 -0600152 return info;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800153}
154
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600155/*
156 * Return list of Global layers available
157 */
158std::vector<VkLayerProperties> GetGlobalLayers()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800159{
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600160 VkResult err;
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600161 std::vector<VkLayerProperties> layers;
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600162 uint32_t layer_count;
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600163
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600164 do {
165 layer_count = 0;
166 err = vkGetGlobalLayerProperties(&layer_count, NULL);
167
168 if (err == VK_SUCCESS) {
169 layers.reserve(layer_count);
170 err = vkGetGlobalLayerProperties(&layer_count, &layers[0]);
171 }
172 } while (err == VK_INCOMPLETE);
173
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600174 assert(err == VK_SUCCESS);
175
176 return layers;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800177}
178
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600179/*
180 * Return list of Global extensions provided by the ICD / Loader
181 */
182std::vector<VkExtensionProperties> GetGlobalExtensions()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800183{
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600184 return GetGlobalExtensions(NULL);
185}
186
187/*
188 * Return list of Global extensions provided by the specified layer
189 * If pLayerName is NULL, will return extensions implemented by the loader / ICDs
190 */
191std::vector<VkExtensionProperties> GetGlobalExtensions(const char *pLayerName)
192{
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600193 std::vector<VkExtensionProperties> exts;
194 uint32_t ext_count;
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600195 VkResult err;
196
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600197 do {
198 ext_count = 0;
199 err = vkGetGlobalExtensionProperties(pLayerName, &ext_count, NULL);
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600200
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600201 if (err == VK_SUCCESS) {
Courtney Goeltzenleuchter381f3a22015-07-06 15:45:58 -0600202 exts.resize(ext_count);
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600203 err = vkGetGlobalExtensionProperties(pLayerName, &ext_count, &exts[0]);
204 }
205 } while (err == VK_INCOMPLETE);
206
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600207 assert(err == VK_SUCCESS);
208
209 return exts;
210}
211
212/*
213 * Return list of PhysicalDevice extensions provided by the ICD / Loader
214 */
Chia-I Wu999f0482015-07-03 10:32:05 +0800215std::vector<VkExtensionProperties> PhysicalDevice::extensions() const
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600216{
217 return extensions(NULL);
218}
219
220/*
221 * Return list of PhysicalDevice extensions provided by the specified layer
222 * If pLayerName is NULL, will return extensions for ICD / loader.
223 */
Chia-I Wu999f0482015-07-03 10:32:05 +0800224std::vector<VkExtensionProperties> PhysicalDevice::extensions(const char *pLayerName) const
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600225{
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600226 std::vector<VkExtensionProperties> exts;
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600227 VkResult err;
228
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600229 do {
230 uint32_t extCount = 0;
Chia-I Wu999f0482015-07-03 10:32:05 +0800231 err = vkGetPhysicalDeviceExtensionProperties(handle(), pLayerName, &extCount, NULL);
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600232
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600233 if (err == VK_SUCCESS) {
234 exts.reserve(extCount);
Chia-I Wu999f0482015-07-03 10:32:05 +0800235 err = vkGetPhysicalDeviceExtensionProperties(handle(), pLayerName, &extCount, &exts[0]);
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600236 }
237 } while (err == VK_INCOMPLETE);
238
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600239 assert(err == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800240
241 return exts;
242}
243
Chia-I Wu999f0482015-07-03 10:32:05 +0800244VkResult PhysicalDevice::set_memory_type(const uint32_t type_bits, VkMemoryAllocInfo *info, const VkFlags properties) const
Mark Lobodzinskib3fbcd92015-07-02 16:49:40 -0600245{
246 uint32_t type_mask = type_bits;
247 // Search memtypes to find first index with those properties
248 for (uint32_t i = 0; i < 32; i++) {
249 if ((type_mask & 1) == 1) {
250 // Type is available, does it match user properties?
251 if ((memory_properties_.memoryTypes[i].propertyFlags & properties) == properties) {
252 info->memoryTypeIndex = i;
253 return VK_SUCCESS;
254 }
255 }
256 type_mask >>= 1;
257 }
258 // No memory types matched, return failure
259 return VK_UNSUPPORTED;
260}
261
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600262/*
263 * Return list of PhysicalDevice layers
264 */
Chia-I Wu999f0482015-07-03 10:32:05 +0800265std::vector<VkLayerProperties> PhysicalDevice::layers() const
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600266{
267 std::vector<VkLayerProperties> layer_props;
268 VkResult err;
269
270 do {
271 uint32_t layer_count = 0;
Chia-I Wu999f0482015-07-03 10:32:05 +0800272 err = vkGetPhysicalDeviceLayerProperties(handle(), &layer_count, NULL);
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600273
274 if (err == VK_SUCCESS) {
275 layer_props.reserve(layer_count);
Chia-I Wu999f0482015-07-03 10:32:05 +0800276 err = vkGetPhysicalDeviceLayerProperties(handle(), &layer_count, &layer_props[0]);
Courtney Goeltzenleuchtercd69eee2015-07-06 09:10:47 -0600277 }
278 } while (err == VK_INCOMPLETE);
279
280 assert(err == VK_SUCCESS);
281
282 return layer_props;
283}
284
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600285void BaseObject::init(VkObject obj, VkObjectType type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800286{
287 EXPECT(!initialized());
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600288 reinit(obj, type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800289}
290
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600291void BaseObject::reinit(VkObject obj, VkObjectType type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800292{
293 obj_ = obj;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600294 object_type_ = type;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800295 own_obj_ = own;
296}
297
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600298uint32_t Object::memory_allocation_count() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800299{
Mark Lobodzinski23065352015-05-29 09:32:35 -0500300 return 1;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800301}
302
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600303std::vector<VkMemoryRequirements> Object::memory_requirements() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800304{
Mark Lobodzinski23065352015-05-29 09:32:35 -0500305 uint32_t num_allocations = 1;
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600306 std::vector<VkMemoryRequirements> info =
Chia-I Wuf368b602015-07-03 10:41:20 +0800307 get_memory_reqs<VkMemoryRequirements>(dev_->handle(), type(), obj(), 0);
Jon Ashburn7e781952015-01-16 09:37:43 -0700308 EXPECT(info.size() == num_allocations);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800309 if (info.size() == 1 && !info[0].size)
310 info.clear();
311
312 return info;
313}
314
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600315void Object::init(VkObject obj, VkObjectType object_type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800316{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600317 BaseObject::init(obj, object_type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800318 mem_alloc_count_ = memory_allocation_count();
319}
320
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600321void Object::reinit(VkObject obj, VkObjectType object_type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800322{
323 cleanup();
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600324 BaseObject::reinit(obj, object_type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800325 mem_alloc_count_ = memory_allocation_count();
326}
327
328void Object::cleanup()
329{
330 if (!initialized())
331 return;
332
Courtney Goeltzenleuchterde69c412015-06-14 21:31:09 -0600333 if (own())
Chia-I Wuf368b602015-07-03 10:41:20 +0800334 EXPECT(vkDestroyObject(dev_->handle(), type(), obj()) == VK_SUCCESS);
Courtney Goeltzenleuchterde69c412015-06-14 21:31:09 -0600335
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800336 if (internal_mems_) {
337 delete[] internal_mems_;
338 internal_mems_ = NULL;
339 primary_mem_ = NULL;
340 }
341
342 mem_alloc_count_ = 0;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800343}
344
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800345void Object::bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800346{
Tony Barbour44bb3ab2015-04-09 16:00:18 -0600347 bound = true;
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800348 EXPECT(vkBindObjectMemory(dev_->handle(), type(), obj(), mem.handle(), mem_offset) == VK_SUCCESS);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800349}
350
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600351void Object::alloc_memory()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800352{
353 if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
354 return;
355
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800356 internal_mems_ = new DeviceMemory[mem_alloc_count_];
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800357
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600358 const std::vector<VkMemoryRequirements> mem_reqs = memory_requirements();
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800359 VkMemoryAllocInfo info;
Jon Ashburn8a5da752015-01-19 15:00:26 -0700360
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800361 for (int i = 0; i < mem_reqs.size(); i++) {
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800362 info = DeviceMemory::alloc_info(mem_reqs[i].size, 0);
Chia-I Wu999f0482015-07-03 10:32:05 +0800363 dev_->phy().set_memory_type(mem_reqs[i].memoryTypeBits, &info, 0);
Mark Lobodzinskie39f6952015-04-16 08:52:00 -0500364 primary_mem_ = &internal_mems_[i];
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600365 internal_mems_[i].init(*dev_, info);
Mark Lobodzinski23065352015-05-29 09:32:35 -0500366 bind_memory(internal_mems_[i], 0);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800367 }
368}
369
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600370void Object::alloc_memory(VkMemoryPropertyFlags &reqs)
371{
372 if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
373 return;
374
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800375 internal_mems_ = new DeviceMemory[mem_alloc_count_];
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600376
377 std::vector<VkMemoryRequirements> mem_reqs = memory_requirements();
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800378 VkMemoryAllocInfo info;
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600379
380 for (int i = 0; i < mem_reqs.size(); i++) {
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800381 info = DeviceMemory::alloc_info(mem_reqs[i].size, 0);
Chia-I Wu999f0482015-07-03 10:32:05 +0800382 dev_->phy().set_memory_type(mem_reqs[i].memoryTypeBits, &info, reqs);
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600383 primary_mem_ = &internal_mems_[i];
384 internal_mems_[i].init(*dev_, info);
Mark Lobodzinski23065352015-05-29 09:32:35 -0500385 bind_memory(internal_mems_[i], 0);
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600386 }
387}
388
Tony Barbourd1c35722015-04-16 15:59:00 -0600389std::vector<VkDeviceMemory> Object::memories() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800390{
Tony Barbourd1c35722015-04-16 15:59:00 -0600391 std::vector<VkDeviceMemory> mems;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800392 if (internal_mems_) {
393 mems.reserve(mem_alloc_count_);
394 for (uint32_t i = 0; i < mem_alloc_count_; i++)
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800395 mems.push_back(internal_mems_[i].handle());
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800396 }
397
398 return mems;
399}
400
401Device::~Device()
402{
403 if (!initialized())
404 return;
405
406 for (int i = 0; i < QUEUE_COUNT; i++) {
407 for (std::vector<Queue *>::iterator it = queues_[i].begin(); it != queues_[i].end(); it++)
408 delete *it;
409 queues_[i].clear();
410 }
411
Chia-I Wuf368b602015-07-03 10:41:20 +0800412 EXPECT(vkDestroyDevice(handle()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800413}
414
Courtney Goeltzenleuchter5bac6092015-07-07 11:47:33 -0600415void Device::init(std::vector<const char *> &layers, std::vector<const char *> &extensions)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800416{
417 // request all queues
Chia-I Wu999f0482015-07-03 10:32:05 +0800418 const std::vector<VkPhysicalDeviceQueueProperties> queue_props = phy_.queue_properties();
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600419 std::vector<VkDeviceQueueCreateInfo> queue_info;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800420 queue_info.reserve(queue_props.size());
421 for (int i = 0; i < queue_props.size(); i++) {
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600422 VkDeviceQueueCreateInfo qi = {};
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800423 qi.queueNodeIndex = i;
424 qi.queueCount = queue_props[i].queueCount;
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600425 if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700426 graphics_queue_node_index_ = i;
427 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800428 queue_info.push_back(qi);
429 }
430
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600431 VkDeviceCreateInfo dev_info = {};
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600432 dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600433 dev_info.pNext = NULL;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800434 dev_info.queueRecordCount = queue_info.size();
435 dev_info.pRequestedQueues = &queue_info[0];
Courtney Goeltzenleuchter5bac6092015-07-07 11:47:33 -0600436 dev_info.layerCount = layers.size();
437 dev_info.ppEnabledLayerNames = &layers[0];
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600438 dev_info.extensionCount = extensions.size();
Courtney Goeltzenleuchter110fdf92015-06-29 15:39:26 -0600439 dev_info.ppEnabledExtensionNames = &extensions[0];
Jon Ashburn9fc13ba2015-05-18 09:06:15 -0600440 dev_info.flags = 0;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800441
442 init(dev_info);
443}
444
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600445void Device::init(const VkDeviceCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800446{
Chia-I Wuf368b602015-07-03 10:41:20 +0800447 VkDevice dev;
448
449 if (EXPECT(vkCreateDevice(phy_.handle(), &info, &dev) == VK_SUCCESS))
450 Handle::init(dev);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800451
452 init_queues();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800453 init_formats();
454}
455
456void Device::init_queues()
457{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600458 VkResult err;
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700459 uint32_t queue_node_count;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800460
Chia-I Wu999f0482015-07-03 10:32:05 +0800461 err = vkGetPhysicalDeviceQueueCount(phy_.handle(), &queue_node_count);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600462 EXPECT(err == VK_SUCCESS);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700463 EXPECT(queue_node_count >= 1);
464
Tony Barbour3d69c9e2015-05-20 16:53:31 -0600465 VkPhysicalDeviceQueueProperties* queue_props = new VkPhysicalDeviceQueueProperties[queue_node_count];
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700466
Chia-I Wu999f0482015-07-03 10:32:05 +0800467 err = vkGetPhysicalDeviceQueueProperties(phy_.handle(), queue_node_count, queue_props);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600468 EXPECT(err == VK_SUCCESS);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700469
Tony Barbour7ea6aa22015-05-22 09:44:58 -0600470 for (uint32_t i = 0; i < queue_node_count; i++) {
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600471 VkQueue queue;
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700472
Tony Barbour7ea6aa22015-05-22 09:44:58 -0600473 for (uint32_t j = 0; j < queue_props[i].queueCount; j++) {
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500474 // TODO: Need to add support for separate MEMMGR and work queues, including synchronization
Chia-I Wuf368b602015-07-03 10:41:20 +0800475 err = vkGetDeviceQueue(handle(), i, j, &queue);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600476 EXPECT(err == VK_SUCCESS);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700477
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600478 if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700479 queues_[GRAPHICS].push_back(new Queue(queue));
480 }
481
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600482 if (queue_props[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700483 queues_[COMPUTE].push_back(new Queue(queue));
484 }
485
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600486 if (queue_props[i].queueFlags & VK_QUEUE_DMA_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700487 queues_[DMA].push_back(new Queue(queue));
488 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800489 }
490 }
491
Chris Forbes02038792015-06-04 10:49:27 +1200492 delete[] queue_props;
Tony Barbour3d69c9e2015-05-20 16:53:31 -0600493
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800494 EXPECT(!queues_[GRAPHICS].empty() || !queues_[COMPUTE].empty());
495}
496
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800497void Device::init_formats()
498{
Tony Barbourd1c35722015-04-16 15:59:00 -0600499 for (int f = VK_FORMAT_BEGIN_RANGE; f <= VK_FORMAT_END_RANGE; f++) {
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600500 const VkFormat fmt = static_cast<VkFormat>(f);
501 const VkFormatProperties props = format_properties(fmt);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800502
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700503 if (props.linearTilingFeatures) {
Tony Barbourd1c35722015-04-16 15:59:00 -0600504 const Format tmp = { fmt, VK_IMAGE_TILING_LINEAR, props.linearTilingFeatures };
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700505 formats_.push_back(tmp);
506 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800507
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700508 if (props.optimalTilingFeatures) {
Tony Barbourd1c35722015-04-16 15:59:00 -0600509 const Format tmp = { fmt, VK_IMAGE_TILING_OPTIMAL, props.optimalTilingFeatures };
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700510 formats_.push_back(tmp);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800511 }
512 }
513
514 EXPECT(!formats_.empty());
515}
516
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600517VkFormatProperties Device::format_properties(VkFormat format)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800518{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600519 VkFormatProperties data;
Chia-I Wu999f0482015-07-03 10:32:05 +0800520 if (!EXPECT(vkGetPhysicalDeviceFormatInfo(phy().handle(), format, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800521 memset(&data, 0, sizeof(data));
522
523 return data;
524}
525
526void Device::wait()
527{
Chia-I Wuf368b602015-07-03 10:41:20 +0800528 EXPECT(vkDeviceWaitIdle(handle()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800529}
530
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600531VkResult Device::wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800532{
Chia-I Wud9e8e822015-07-03 11:45:55 +0800533 const std::vector<VkFence> fence_handles = make_handles<VkFence>(fences);
534 VkResult err = vkWaitForFences(handle(), fence_handles.size(), &fence_handles[0], wait_all, timeout);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600535 EXPECT(err == VK_SUCCESS || err == VK_TIMEOUT);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800536
537 return err;
538}
539
Chia-I Wu9d00ed72015-05-25 16:27:55 +0800540VkResult Device::update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies)
541{
Chia-I Wuf368b602015-07-03 10:41:20 +0800542 return vkUpdateDescriptorSets(handle(), writes.size(), &writes[0], copies.size(), &copies[0]);
Chia-I Wu9d00ed72015-05-25 16:27:55 +0800543}
544
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600545void Queue::submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800546{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600547 const std::vector<VkCmdBuffer> cmd_objs = make_objects<VkCmdBuffer>(cmds);
Chia-I Wud9e8e822015-07-03 11:45:55 +0800548 EXPECT(vkQueueSubmit(handle(), cmd_objs.size(), &cmd_objs[0], fence.handle()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800549}
550
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600551void Queue::submit(const CmdBuffer &cmd, Fence &fence)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800552{
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600553 submit(std::vector<const CmdBuffer*>(1, &cmd), fence);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800554}
555
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600556void Queue::submit(const CmdBuffer &cmd)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800557{
558 Fence fence;
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600559 submit(cmd, fence);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800560}
561
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800562void Queue::wait()
563{
Chia-I Wudf12ffd2015-07-03 10:53:18 +0800564 EXPECT(vkQueueWaitIdle(handle()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800565}
566
Courtney Goeltzenleuchterebb95842015-03-25 17:14:29 -0600567void Queue::signal_semaphore(Semaphore &sem)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800568{
Chia-I Wu6b1c2482015-07-03 11:49:42 +0800569 EXPECT(vkQueueSignalSemaphore(handle(), sem.handle()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800570}
571
Courtney Goeltzenleuchterebb95842015-03-25 17:14:29 -0600572void Queue::wait_semaphore(Semaphore &sem)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800573{
Chia-I Wu6b1c2482015-07-03 11:49:42 +0800574 EXPECT(vkQueueWaitSemaphore(handle(), sem.handle()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800575}
576
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800577DeviceMemory::~DeviceMemory()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800578{
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800579 if (initialized())
580 EXPECT(vkFreeMemory(device(), handle()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800581}
582
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800583void DeviceMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800584{
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800585 NON_DISPATCHABLE_HANDLE_INIT(vkAllocMemory, dev, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800586}
587
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800588const void *DeviceMemory::map(VkFlags flags) const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800589{
590 void *data;
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800591 if (!EXPECT(vkMapMemory(device(), handle(), 0 ,0, flags, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800592 data = NULL;
593
594 return data;
595}
596
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800597void *DeviceMemory::map(VkFlags flags)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800598{
599 void *data;
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800600 if (!EXPECT(vkMapMemory(device(), handle(), 0, 0, flags, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800601 data = NULL;
602
603 return data;
604}
605
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800606void DeviceMemory::unmap() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800607{
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800608 EXPECT(vkUnmapMemory(device(), handle()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800609}
610
Chia-I Wud9e8e822015-07-03 11:45:55 +0800611NON_DISPATCHABLE_HANDLE_DTOR(Fence, vkDestroyObject, VK_OBJECT_TYPE_FENCE)
612
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600613void Fence::init(const Device &dev, const VkFenceCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800614{
Chia-I Wud9e8e822015-07-03 11:45:55 +0800615 NON_DISPATCHABLE_HANDLE_INIT(vkCreateFence, dev, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800616}
617
Chia-I Wu6b1c2482015-07-03 11:49:42 +0800618NON_DISPATCHABLE_HANDLE_DTOR(Semaphore, vkDestroyObject, VK_OBJECT_TYPE_SEMAPHORE)
619
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600620void Semaphore::init(const Device &dev, const VkSemaphoreCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800621{
Chia-I Wu6b1c2482015-07-03 11:49:42 +0800622 NON_DISPATCHABLE_HANDLE_INIT(vkCreateSemaphore, dev, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800623}
624
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600625void Event::init(const Device &dev, const VkEventCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800626{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600627 DERIVED_OBJECT_TYPE_INIT(vkCreateEvent, dev, VK_OBJECT_TYPE_EVENT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600628 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800629}
630
631void Event::set()
632{
Chia-I Wuf368b602015-07-03 10:41:20 +0800633 EXPECT(vkSetEvent(dev_->handle(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800634}
635
636void Event::reset()
637{
Chia-I Wuf368b602015-07-03 10:41:20 +0800638 EXPECT(vkResetEvent(dev_->handle(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800639}
640
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600641void QueryPool::init(const Device &dev, const VkQueryPoolCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800642{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600643 DERIVED_OBJECT_TYPE_INIT(vkCreateQueryPool, dev, VK_OBJECT_TYPE_QUERY_POOL, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600644 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800645}
646
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600647VkResult QueryPool::results(uint32_t start, uint32_t count, size_t size, void *data)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800648{
649 size_t tmp = size;
Chia-I Wuf368b602015-07-03 10:41:20 +0800650 VkResult err = vkGetQueryPoolResults(dev_->handle(), obj(), start, count, &tmp, data, 0);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600651 if (err == VK_SUCCESS) {
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800652 if (!EXPECT(tmp == size))
653 memset(data, 0, size);
654 } else {
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600655 EXPECT(err == VK_NOT_READY);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800656 }
657
658 return err;
659}
660
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600661void Buffer::init(const Device &dev, const VkBufferCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800662{
663 init_no_mem(dev, info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600664 alloc_memory();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800665}
666
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600667void Buffer::init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags &reqs)
668{
669 init_no_mem(dev, info);
670 alloc_memory(reqs);
671}
672
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600673void Buffer::init_no_mem(const Device &dev, const VkBufferCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800674{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600675 DERIVED_OBJECT_TYPE_INIT(vkCreateBuffer, dev, VK_OBJECT_TYPE_BUFFER, &info);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800676 create_info_ = info;
677}
678
Mark Lobodzinski23065352015-05-29 09:32:35 -0500679void Buffer::bind_memory(VkDeviceSize offset, VkDeviceSize size,
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800680 const DeviceMemory &mem, VkDeviceSize mem_offset)
Mark Lobodzinski942b1722015-05-11 17:21:15 -0500681{
Chia-I Wudf12ffd2015-07-03 10:53:18 +0800682 VkQueue queue = dev_->graphics_queues()[0]->handle();
Mark Lobodzinski16e8bef2015-07-03 15:58:09 -0600683 VkSparseMemoryBindInfo bindInfo;
684 memset(&bindInfo, 0, sizeof(VkSparseMemoryBindInfo));
685 bindInfo.offset = offset;
686 bindInfo.memOffset = mem_offset;
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800687 bindInfo.mem = mem.handle();
Mark Lobodzinski16e8bef2015-07-03 15:58:09 -0600688 EXPECT(vkQueueBindSparseBufferMemory(queue, obj(), 1, &bindInfo) == VK_SUCCESS);
Mark Lobodzinski942b1722015-05-11 17:21:15 -0500689}
690
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600691void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800692{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600693 DERIVED_OBJECT_TYPE_INIT(vkCreateBufferView, dev, VK_OBJECT_TYPE_BUFFER_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600694 alloc_memory();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800695}
696
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600697void Image::init(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800698{
699 init_no_mem(dev, info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600700 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800701}
702
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600703void Image::init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags &reqs)
704{
705 init_no_mem(dev, info);
706 alloc_memory(reqs);
707}
708
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600709void Image::init_no_mem(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800710{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600711 DERIVED_OBJECT_TYPE_INIT(vkCreateImage, dev, VK_OBJECT_TYPE_IMAGE, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800712 init_info(dev, info);
713}
714
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600715void Image::init_info(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800716{
717 create_info_ = info;
718
719 for (std::vector<Device::Format>::const_iterator it = dev.formats().begin(); it != dev.formats().end(); it++) {
720 if (memcmp(&it->format, &create_info_.format, sizeof(it->format)) == 0 && it->tiling == create_info_.tiling) {
721 format_features_ = it->features;
722 break;
723 }
724 }
725}
726
Mark Lobodzinski16e8bef2015-07-03 15:58:09 -0600727void Image::bind_memory(const Device &dev, const VkSparseImageMemoryBindInfo &info,
Chia-I Wuf8f074f2015-07-03 10:58:57 +0800728 const DeviceMemory &mem, VkDeviceSize mem_offset)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800729{
Chia-I Wudf12ffd2015-07-03 10:53:18 +0800730 VkQueue queue = dev.graphics_queues()[0]->handle();
Mark Lobodzinski16e8bef2015-07-03 15:58:09 -0600731 EXPECT(vkQueueBindSparseImageMemory(queue, obj(), 1, &info) == VK_SUCCESS);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800732}
733
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600734VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800735{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600736 VkSubresourceLayout data;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800737 size_t size = sizeof(data);
Chia-I Wuf368b602015-07-03 10:41:20 +0800738 if (!EXPECT(vkGetImageSubresourceLayout(dev_->handle(), obj(), &subres, &data) == VK_SUCCESS && size == sizeof(data)))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800739 memset(&data, 0, sizeof(data));
740
741 return data;
742}
743
744bool Image::transparent() const
745{
Tony Barbourd1c35722015-04-16 15:59:00 -0600746 return (create_info_.tiling == VK_IMAGE_TILING_LINEAR &&
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800747 create_info_.samples == 1 &&
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600748 !(create_info_.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
749 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)));
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800750}
751
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600752void ImageView::init(const Device &dev, const VkImageViewCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800753{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600754 DERIVED_OBJECT_TYPE_INIT(vkCreateImageView, dev, VK_OBJECT_TYPE_IMAGE_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600755 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800756}
757
Chia-I Wu08accc62015-07-07 11:50:03 +0800758void AttachmentView::init(const Device &dev, const VkAttachmentViewCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800759{
Chia-I Wu08accc62015-07-07 11:50:03 +0800760 DERIVED_OBJECT_TYPE_INIT(vkCreateAttachmentView, dev, VK_OBJECT_TYPE_ATTACHMENT_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600761 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800762}
763
Courtney Goeltzenleuchteree4027d2015-06-28 13:01:17 -0600764void ShaderModule::init(const Device &dev, const VkShaderModuleCreateInfo &info)
765{
766 DERIVED_OBJECT_TYPE_INIT(vkCreateShaderModule, dev, VK_OBJECT_TYPE_SHADER_MODULE, &info);
767}
768
769VkResult ShaderModule::init_try(const Device &dev, const VkShaderModuleCreateInfo &info)
770{
771 /*
772 * Note: Cannot use DERIVED_OBJECT_TYPE_INIT as we need the
773 * return code.
774 */
775 VkShaderModule sh;
776 dev_ = &dev;
Chia-I Wuf368b602015-07-03 10:41:20 +0800777 VkResult err = vkCreateShaderModule(dev.handle(), &info, &sh);
Courtney Goeltzenleuchteree4027d2015-06-28 13:01:17 -0600778 if (err == VK_SUCCESS)
779 Object::init(sh, VK_OBJECT_TYPE_SHADER_MODULE);
780
781 return err;
782}
783
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600784void Shader::init(const Device &dev, const VkShaderCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800785{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600786 DERIVED_OBJECT_TYPE_INIT(vkCreateShader, dev, VK_OBJECT_TYPE_SHADER, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800787}
788
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600789VkResult Shader::init_try(const Device &dev, const VkShaderCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800790{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600791 /*
792 * Note: Cannot use DERIVED_OBJECT_TYPE_INIT as we need the
793 * return code.
794 */
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600795 VkShader sh;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600796 dev_ = &dev;
Chia-I Wuf368b602015-07-03 10:41:20 +0800797 VkResult err = vkCreateShader(dev.handle(), &info, &sh);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600798 if (err == VK_SUCCESS)
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600799 Object::init(sh, VK_OBJECT_TYPE_SHADER);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800800
801 return err;
802}
803
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600804void Pipeline::init(const Device &dev, const VkGraphicsPipelineCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800805{
Jon Ashburnc669cc62015-07-09 15:02:25 -0600806 VkPipelineCache cache;
807 VkPipelineCacheCreateInfo ci;
808 memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
809 ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
Chia-I Wuf368b602015-07-03 10:41:20 +0800810 VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
Jon Ashburnc669cc62015-07-09 15:02:25 -0600811 if (err == VK_SUCCESS) {
812 DERIVED_OBJECT_TYPE_INIT(vkCreateGraphicsPipelines, dev, VK_OBJECT_TYPE_PIPELINE, cache, 1, &info);
813 alloc_memory();
Chia-I Wuf368b602015-07-03 10:41:20 +0800814 vkDestroyPipelineCache(dev.handle(), cache);
Jon Ashburnc669cc62015-07-09 15:02:25 -0600815 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800816}
817
Chris Forbes95292b12015-05-25 11:13:26 +1200818VkResult Pipeline::init_try(const Device &dev, const VkGraphicsPipelineCreateInfo &info)
819{
820 VkPipeline pipe;
Jon Ashburnc669cc62015-07-09 15:02:25 -0600821 VkPipelineCache cache;
822 VkPipelineCacheCreateInfo ci;
Chris Forbes95292b12015-05-25 11:13:26 +1200823 dev_ = &dev;
Jon Ashburnc669cc62015-07-09 15:02:25 -0600824 memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
825 ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
Chia-I Wuf368b602015-07-03 10:41:20 +0800826 VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
827 EXPECT(err == VK_SUCCESS);
Chris Forbes95292b12015-05-25 11:13:26 +1200828 if (err == VK_SUCCESS) {
Chia-I Wuf368b602015-07-03 10:41:20 +0800829 err = vkCreateGraphicsPipelines(dev.handle(), cache, 1, &info, &pipe);
Jon Ashburnc669cc62015-07-09 15:02:25 -0600830 if (err == VK_SUCCESS) {
831 Object::init(pipe, VK_OBJECT_TYPE_PIPELINE);
832 alloc_memory();
Chia-I Wuf368b602015-07-03 10:41:20 +0800833 vkDestroyPipelineCache(dev.handle(), cache);
Jon Ashburnc669cc62015-07-09 15:02:25 -0600834 }
Chris Forbes95292b12015-05-25 11:13:26 +1200835 }
836
837 return err;
838}
839
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600840
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600841void Pipeline::init(const Device &dev, const VkComputePipelineCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800842{
Jon Ashburnc669cc62015-07-09 15:02:25 -0600843 VkPipelineCache cache;
844 VkPipelineCacheCreateInfo ci;
845 memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
846 ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
Chia-I Wuf368b602015-07-03 10:41:20 +0800847 VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
Jon Ashburnc669cc62015-07-09 15:02:25 -0600848 if (err == VK_SUCCESS) {
849 DERIVED_OBJECT_TYPE_INIT(vkCreateComputePipelines, dev, VK_OBJECT_TYPE_PIPELINE, cache, 1, &info);
850 alloc_memory();
Chia-I Wuf368b602015-07-03 10:41:20 +0800851 vkDestroyPipelineCache(dev.handle(), cache);
Jon Ashburnc669cc62015-07-09 15:02:25 -0600852 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800853}
854
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600855void Sampler::init(const Device &dev, const VkSamplerCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800856{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600857 DERIVED_OBJECT_TYPE_INIT(vkCreateSampler, dev, VK_OBJECT_TYPE_SAMPLER, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600858 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800859}
860
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600861void DescriptorSetLayout::init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800862{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600863 DERIVED_OBJECT_TYPE_INIT(vkCreateDescriptorSetLayout, dev, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600864 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800865}
866
Mark Lobodzinski0fadf5f2015-04-17 14:11:39 -0500867void PipelineLayout::init(const Device &dev, VkPipelineLayoutCreateInfo &info, const std::vector<const DescriptorSetLayout *> &layouts)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800868{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600869 const std::vector<VkDescriptorSetLayout> layout_objs = make_objects<VkDescriptorSetLayout>(layouts);
Mark Lobodzinski0fadf5f2015-04-17 14:11:39 -0500870 info.pSetLayouts = &layout_objs[0];
Chia-I Wu41126e52015-03-26 15:27:55 +0800871
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600872 DERIVED_OBJECT_TYPE_INIT(vkCreatePipelineLayout, dev, VK_OBJECT_TYPE_PIPELINE_LAYOUT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600873 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800874}
875
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600876void DescriptorPool::init(const Device &dev, VkDescriptorPoolUsage usage,
877 uint32_t max_sets, const VkDescriptorPoolCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800878{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600879 DERIVED_OBJECT_TYPE_INIT(vkCreateDescriptorPool, dev, VK_OBJECT_TYPE_DESCRIPTOR_POOL, usage, max_sets, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600880 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800881}
882
Chia-I Wufae40bc2015-03-26 15:23:52 +0800883void DescriptorPool::reset()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800884{
Chia-I Wuf368b602015-07-03 10:41:20 +0800885 EXPECT(vkResetDescriptorPool(dev_->handle(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800886}
887
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500888std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const std::vector<const DescriptorSetLayout *> &layouts)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800889{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600890 const std::vector<VkDescriptorSetLayout> layout_objs = make_objects<VkDescriptorSetLayout>(layouts);
Chia-I Wu11078b02015-01-04 16:27:24 +0800891
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600892 std::vector<VkDescriptorSet> set_objs;
Chia-I Wu11078b02015-01-04 16:27:24 +0800893 set_objs.resize(layout_objs.size());
894
895 uint32_t set_count;
Chia-I Wuf368b602015-07-03 10:41:20 +0800896 VkResult err = vkAllocDescriptorSets(dev_->handle(), obj(), usage, layout_objs.size(), &layout_objs[0], &set_objs[0], &set_count);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600897 if (err == VK_SUCCESS)
Chia-I Wu11078b02015-01-04 16:27:24 +0800898 EXPECT(set_count == set_objs.size());
899 set_objs.resize(set_count);
900
901 std::vector<DescriptorSet *> sets;
902 sets.reserve(set_count);
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600903 for (std::vector<VkDescriptorSet>::const_iterator it = set_objs.begin(); it != set_objs.end(); it++) {
Chia-I Wu11078b02015-01-04 16:27:24 +0800904 // do descriptor sets need memories bound?
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600905 DescriptorSet *descriptorSet = new DescriptorSet(dev, *it);
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500906 sets.push_back(descriptorSet);
Chia-I Wu11078b02015-01-04 16:27:24 +0800907 }
Chia-I Wu11078b02015-01-04 16:27:24 +0800908 return sets;
909}
910
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500911std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout, uint32_t count)
Chia-I Wu11078b02015-01-04 16:27:24 +0800912{
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500913 return alloc_sets(dev, usage, std::vector<const DescriptorSetLayout *>(count, &layout));
Chia-I Wu11078b02015-01-04 16:27:24 +0800914}
915
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500916DescriptorSet *DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout)
Chia-I Wu11078b02015-01-04 16:27:24 +0800917{
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500918 std::vector<DescriptorSet *> set = alloc_sets(dev, usage, layout, 1);
Chia-I Wu11078b02015-01-04 16:27:24 +0800919 return (set.empty()) ? NULL : set[0];
920}
921
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600922void DynamicVpStateObject::init(const Device &dev, const VkDynamicVpStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800923{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600924 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicViewportState, dev, VK_OBJECT_TYPE_DYNAMIC_VP_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600925 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800926}
927
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600928void DynamicRsStateObject::init(const Device &dev, const VkDynamicRsStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800929{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600930 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicRasterState, dev, VK_OBJECT_TYPE_DYNAMIC_RS_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600931 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800932}
933
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600934void DynamicCbStateObject::init(const Device &dev, const VkDynamicCbStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800935{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600936 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicColorBlendState, dev, VK_OBJECT_TYPE_DYNAMIC_CB_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600937 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800938}
939
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600940void DynamicDsStateObject::init(const Device &dev, const VkDynamicDsStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800941{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600942 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicDepthStencilState, dev, VK_OBJECT_TYPE_DYNAMIC_DS_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600943 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800944}
945
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600946void CmdBuffer::init(const Device &dev, const VkCmdBufferCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800947{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600948 DERIVED_OBJECT_TYPE_INIT(vkCreateCommandBuffer, dev, VK_OBJECT_TYPE_COMMAND_BUFFER, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800949}
950
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600951void CmdBuffer::begin(const VkCmdBufferBeginInfo *info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800952{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600953 EXPECT(vkBeginCommandBuffer(obj(), info) == VK_SUCCESS);
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700954}
955
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800956void CmdBuffer::begin()
957{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600958 VkCmdBufferBeginInfo info = {};
Tony Barbourd1c35722015-04-16 15:59:00 -0600959 info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600960 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
961 info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700962
963 begin(&info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800964}
965
966void CmdBuffer::end()
967{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600968 EXPECT(vkEndCommandBuffer(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800969}
970
971void CmdBuffer::reset()
972{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600973 EXPECT(vkResetCommandBuffer(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800974}
975
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600976}; // namespace vk_testing