blob: a9d0b215b6e87002850e707690a210302e7cabfb [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
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -060030#define DERIVED_OBJECT_TYPE_INIT(create_func, dev, vk_object_type, ...) \
31 do { \
32 obj_type obj; \
33 dev_ = &dev; \
34 if (EXPECT(create_func(dev.obj(), __VA_ARGS__, &obj) == VK_SUCCESS)) \
35 base_type::init(obj, vk_object_type); \
Mike Stroyanb050c682015-04-17 12:36:38 -060036 } while (0)
37
Chia-I Wuf1e2e992014-12-27 14:12:52 +080038#define STRINGIFY(x) #x
39#define EXPECT(expr) ((expr) ? true : expect_failure(STRINGIFY(expr), __FILE__, __LINE__, __FUNCTION__))
Mark Lobodzinski40f7f402015-04-16 11:44:05 -050040
Chia-I Wuf1e2e992014-12-27 14:12:52 +080041
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -060042vk_testing::ErrorCallback error_callback;
Chia-I Wuf1e2e992014-12-27 14:12:52 +080043
44bool expect_failure(const char *expr, const char *file, unsigned int line, const char *function)
45{
46 if (error_callback) {
47 error_callback(expr, file, line, function);
48 } else {
49 std::cerr << file << ":" << line << ": " << function <<
50 ": Expectation `" << expr << "' failed.\n";
51 }
52
53 return false;
54}
55
56template<class T, class S>
57std::vector<T> make_objects(const std::vector<S> &v)
58{
59 std::vector<T> objs;
60 objs.reserve(v.size());
61 for (typename std::vector<S>::const_iterator it = v.begin(); it != v.end(); it++)
62 objs.push_back((*it)->obj());
63 return objs;
64}
65
66template<typename T>
Tony Barbourd1c35722015-04-16 15:59:00 -060067std::vector<T> get_info(VkPhysicalDevice gpu, VkPhysicalDeviceInfoType type, size_t min_elems)
Chia-I Wuf1e2e992014-12-27 14:12:52 +080068{
69 std::vector<T> info;
Jon Ashburnc0521e72015-02-11 09:36:41 -070070 size_t size;
Tony Barbourd1c35722015-04-16 15:59:00 -060071 if (EXPECT(vkGetPhysicalDeviceInfo(gpu, type, &size, NULL) == VK_SUCCESS && size % sizeof(T) == 0)) {
Chia-I Wuf1e2e992014-12-27 14:12:52 +080072 info.resize(size / sizeof(T));
Tony Barbourd1c35722015-04-16 15:59:00 -060073 if (!EXPECT(vkGetPhysicalDeviceInfo(gpu, type, &size, &info[0]) == VK_SUCCESS && size == info.size() * sizeof(T)))
Chia-I Wuf1e2e992014-12-27 14:12:52 +080074 info.clear();
75 }
76
77 if (info.size() < min_elems)
78 info.resize(min_elems);
79
80 return info;
81}
82
83template<typename T>
Mike Stroyanb050c682015-04-17 12:36:38 -060084std::vector<T> get_info(VkDevice device, VkObjectType object_type, VkObject obj, VkObjectInfoType type, size_t min_elems)
Chia-I Wuf1e2e992014-12-27 14:12:52 +080085{
86 std::vector<T> info;
Jon Ashburnc0521e72015-02-11 09:36:41 -070087 size_t size;
Mike Stroyanb050c682015-04-17 12:36:38 -060088 if (EXPECT(vkGetObjectInfo(device, object_type, obj, type, &size, NULL) == VK_SUCCESS && size % sizeof(T) == 0)) {
Chia-I Wuf1e2e992014-12-27 14:12:52 +080089 info.resize(size / sizeof(T));
Mike Stroyanb050c682015-04-17 12:36:38 -060090 if (!EXPECT(vkGetObjectInfo(device, object_type, obj, type, &size, &info[0]) == VK_SUCCESS && size == info.size() * sizeof(T)))
Chia-I Wuf1e2e992014-12-27 14:12:52 +080091 info.clear();
92 }
93
94 if (info.size() < min_elems)
95 info.resize(min_elems);
96
97 return info;
98}
99
100} // namespace
101
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600102namespace vk_testing {
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800103
104void set_error_callback(ErrorCallback callback)
105{
106 error_callback = callback;
107}
108
Tony Barbourd1c35722015-04-16 15:59:00 -0600109VkPhysicalDeviceProperties PhysicalGpu::properties() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800110{
Tony Barbourd1c35722015-04-16 15:59:00 -0600111 return get_info<VkPhysicalDeviceProperties>(gpu_, VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES, 1)[0];
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800112}
113
Tony Barbourd1c35722015-04-16 15:59:00 -0600114VkPhysicalDevicePerformance PhysicalGpu::performance() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800115{
Tony Barbourd1c35722015-04-16 15:59:00 -0600116 return get_info<VkPhysicalDevicePerformance>(gpu_, VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE, 1)[0];
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800117}
118
Tony Barbourd1c35722015-04-16 15:59:00 -0600119std::vector<VkPhysicalDeviceQueueProperties> PhysicalGpu::queue_properties() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800120{
Tony Barbourd1c35722015-04-16 15:59:00 -0600121 return get_info<VkPhysicalDeviceQueueProperties>(gpu_, VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES, 0);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800122}
123
Tony Barbourd1c35722015-04-16 15:59:00 -0600124VkPhysicalDeviceMemoryProperties PhysicalGpu::memory_properties() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800125{
Tony Barbourd1c35722015-04-16 15:59:00 -0600126 return get_info<VkPhysicalDeviceMemoryProperties>(gpu_, VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES, 1)[0];
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800127}
128
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600129void PhysicalGpu::add_extension_dependencies(
130 uint32_t dependency_count,
131 VkExtensionProperties *depencency_props,
132 std::vector<VkExtensionProperties> &ext_list)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800133{
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600134 for (uint32_t i = 0; i < dependency_count; i++) {
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800135
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600136 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800137}
138
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600139std::vector<VkExtensionProperties> PhysicalGpu::extensions() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800140{
Tobin Ehlis9430c782015-04-16 18:04:57 -0600141 // Extensions to enable
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800142 static const char *known_exts[] = {
Chia-I Wuf8693382015-04-16 22:02:10 +0800143 "VK_WSI_LunarG",
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800144 };
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600145 std::vector<VkExtensionProperties> exts;
Tobin Ehlis9430c782015-04-16 18:04:57 -0600146 size_t extSize = sizeof(uint32_t);
147 uint32_t extCount = 0;
148 if (!EXPECT(vkGetGlobalExtensionInfo(VK_EXTENSION_INFO_TYPE_COUNT, 0, &extSize, &extCount) == VK_SUCCESS))
149 return exts;
150
151 VkExtensionProperties extProp;
152 extSize = sizeof(VkExtensionProperties);
153 // TODO : Need to update this if/when we have more than 1 extension to enable
154 for (uint32_t i = 0; i < extCount; i++) {
155 if (!EXPECT(vkGetGlobalExtensionInfo(VK_EXTENSION_INFO_TYPE_PROPERTIES, i, &extSize, &extProp) == VK_SUCCESS))
156 return exts;
157
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600158 if (!strcmp(known_exts[0], extProp.name))
159 exts.push_back(extProp);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800160 }
161
162 return exts;
163}
164
Tony Barbourd1c35722015-04-16 15:59:00 -0600165VkPhysicalDeviceCompatibilityInfo PhysicalGpu::compatibility(const PhysicalGpu &other) const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800166{
Tony Barbourd1c35722015-04-16 15:59:00 -0600167 VkPhysicalDeviceCompatibilityInfo data;
168 if (!EXPECT(vkGetMultiDeviceCompatibility(gpu_, other.gpu_, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800169 memset(&data, 0, sizeof(data));
170
171 return data;
172}
173
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600174void BaseObject::init(VkObject obj, VkObjectType type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800175{
176 EXPECT(!initialized());
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600177 reinit(obj, type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800178}
179
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600180void BaseObject::reinit(VkObject obj, VkObjectType type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800181{
182 obj_ = obj;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600183 object_type_ = type;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800184 own_obj_ = own;
185}
186
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600187uint32_t Object::memory_allocation_count() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800188{
Mark Lobodzinski23065352015-05-29 09:32:35 -0500189 /// LUGMAL return get_info<uint32_t>(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, 1)[0];
190 return 1;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800191}
192
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600193std::vector<VkMemoryRequirements> Object::memory_requirements() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800194{
Mark Lobodzinski23065352015-05-29 09:32:35 -0500195 //// VkResult err;
196 uint32_t num_allocations = 1;
197 //// size_t num_alloc_size = sizeof(num_allocations);
198 //// err = vkGetObjectInfo(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
199 //// &num_alloc_size, &num_allocations);
200 //// EXPECT(err == VK_SUCCESS && num_alloc_size == sizeof(num_allocations));
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600201 std::vector<VkMemoryRequirements> info =
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600202 get_info<VkMemoryRequirements>(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, 0);
Jon Ashburn7e781952015-01-16 09:37:43 -0700203 EXPECT(info.size() == num_allocations);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800204 if (info.size() == 1 && !info[0].size)
205 info.clear();
206
207 return info;
208}
209
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600210void Object::init(VkObject obj, VkObjectType object_type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800211{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600212 BaseObject::init(obj, object_type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800213 mem_alloc_count_ = memory_allocation_count();
214}
215
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600216void Object::reinit(VkObject obj, VkObjectType object_type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800217{
218 cleanup();
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600219 BaseObject::reinit(obj, object_type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800220 mem_alloc_count_ = memory_allocation_count();
221}
222
223void Object::cleanup()
224{
225 if (!initialized())
226 return;
227
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800228 if (internal_mems_) {
229 delete[] internal_mems_;
230 internal_mems_ = NULL;
231 primary_mem_ = NULL;
232 }
233
234 mem_alloc_count_ = 0;
235
236 if (own())
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600237 EXPECT(vkDestroyObject(dev_->obj(), type(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800238}
239
Mark Lobodzinski23065352015-05-29 09:32:35 -0500240void Object::bind_memory(const GpuMemory &mem, VkDeviceSize mem_offset)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800241{
Tony Barbour44bb3ab2015-04-09 16:00:18 -0600242 bound = true;
Mark Lobodzinski23065352015-05-29 09:32:35 -0500243 EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), mem.obj(), mem_offset) == VK_SUCCESS);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800244}
245
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600246void Object::alloc_memory()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800247{
248 if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
249 return;
250
251 internal_mems_ = new GpuMemory[mem_alloc_count_];
252
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600253 const std::vector<VkMemoryRequirements> mem_reqs = memory_requirements();
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600254 VkMemoryAllocInfo info, *next_info = NULL;
Jon Ashburn8a5da752015-01-19 15:00:26 -0700255
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800256 for (int i = 0; i < mem_reqs.size(); i++) {
Jon Ashburn25bbe462015-01-20 08:50:12 -0700257 info = GpuMemory::alloc_info(mem_reqs[i], next_info);
Mark Lobodzinskie39f6952015-04-16 08:52:00 -0500258 primary_mem_ = &internal_mems_[i];
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600259 internal_mems_[i].init(*dev_, info);
Mark Lobodzinski23065352015-05-29 09:32:35 -0500260 bind_memory(internal_mems_[i], 0);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800261 }
262}
263
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600264void Object::alloc_memory(VkMemoryPropertyFlags &reqs)
265{
266 if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
267 return;
268
269 internal_mems_ = new GpuMemory[mem_alloc_count_];
270
271 std::vector<VkMemoryRequirements> mem_reqs = memory_requirements();
272 VkMemoryAllocInfo info, *next_info = NULL;
273
274 for (int i = 0; i < mem_reqs.size(); i++) {
275 mem_reqs[i].memPropsRequired |= reqs;
276 info = GpuMemory::alloc_info(mem_reqs[i], next_info);
277 primary_mem_ = &internal_mems_[i];
278 internal_mems_[i].init(*dev_, info);
Mark Lobodzinski23065352015-05-29 09:32:35 -0500279 bind_memory(internal_mems_[i], 0);
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600280 }
281}
282
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600283void Object::alloc_memory(const std::vector<VkDeviceMemory> &mems)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800284{
285 if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
286 return;
287
288 internal_mems_ = new GpuMemory[mem_alloc_count_];
289
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600290 const std::vector<VkMemoryRequirements> mem_reqs = memory_requirements();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800291 if (!EXPECT(mem_reqs.size() == mems.size()))
292 return;
293
294 for (int i = 0; i < mem_reqs.size(); i++) {
295 primary_mem_ = &internal_mems_[i];
296
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600297 internal_mems_[i].init(*dev_, mems[i]);
Mark Lobodzinski23065352015-05-29 09:32:35 -0500298 bind_memory(internal_mems_[i], 0);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800299 }
300}
301
Tony Barbourd1c35722015-04-16 15:59:00 -0600302std::vector<VkDeviceMemory> Object::memories() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800303{
Tony Barbourd1c35722015-04-16 15:59:00 -0600304 std::vector<VkDeviceMemory> mems;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800305 if (internal_mems_) {
306 mems.reserve(mem_alloc_count_);
307 for (uint32_t i = 0; i < mem_alloc_count_; i++)
308 mems.push_back(internal_mems_[i].obj());
309 }
310
311 return mems;
312}
313
314Device::~Device()
315{
316 if (!initialized())
317 return;
318
319 for (int i = 0; i < QUEUE_COUNT; i++) {
320 for (std::vector<Queue *>::iterator it = queues_[i].begin(); it != queues_[i].end(); it++)
321 delete *it;
322 queues_[i].clear();
323 }
324
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600325 EXPECT(vkDestroyDevice(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800326}
327
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600328void Device::init(std::vector<VkExtensionProperties> extensions)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800329{
330 // request all queues
Tony Barbourd1c35722015-04-16 15:59:00 -0600331 const std::vector<VkPhysicalDeviceQueueProperties> queue_props = gpu_.queue_properties();
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600332 std::vector<VkDeviceQueueCreateInfo> queue_info;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800333 queue_info.reserve(queue_props.size());
334 for (int i = 0; i < queue_props.size(); i++) {
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600335 VkDeviceQueueCreateInfo qi = {};
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800336 qi.queueNodeIndex = i;
337 qi.queueCount = queue_props[i].queueCount;
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600338 if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700339 graphics_queue_node_index_ = i;
340 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800341 queue_info.push_back(qi);
342 }
343
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600344 VkDeviceCreateInfo dev_info = {};
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600345 dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600346 dev_info.pNext = NULL;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800347 dev_info.queueRecordCount = queue_info.size();
348 dev_info.pRequestedQueues = &queue_info[0];
Courtney Goeltzenleuchterf579fa62015-06-10 17:39:03 -0600349 dev_info.extensionCount = extensions.size();
350 dev_info.pEnabledExtensions = &extensions[0];
Jon Ashburn9fc13ba2015-05-18 09:06:15 -0600351 dev_info.flags = 0;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800352
353 init(dev_info);
354}
355
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600356void Device::init(const VkDeviceCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800357{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600358 VkDevice obj;
359 if (EXPECT(vkCreateDevice(gpu_.obj(), &info, &obj) == VK_SUCCESS)) {
360 base_type::init(obj, VK_OBJECT_TYPE_DEVICE);
361 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800362
363 init_queues();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800364 init_formats();
365}
366
367void Device::init_queues()
368{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600369 VkResult err;
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700370 size_t data_size;
371 uint32_t queue_node_count;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800372
Tony Barbourd1c35722015-04-16 15:59:00 -0600373 err = vkGetPhysicalDeviceInfo(gpu_.obj(), VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES,
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700374 &data_size, NULL);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600375 EXPECT(err == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800376
Tony Barbourd1c35722015-04-16 15:59:00 -0600377 queue_node_count = data_size / sizeof(VkPhysicalDeviceQueueProperties);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700378 EXPECT(queue_node_count >= 1);
379
Tony Barbour3d69c9e2015-05-20 16:53:31 -0600380 VkPhysicalDeviceQueueProperties* queue_props = new VkPhysicalDeviceQueueProperties[queue_node_count];
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700381
Tony Barbourd1c35722015-04-16 15:59:00 -0600382 err = vkGetPhysicalDeviceInfo(gpu_.obj(), VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES,
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700383 &data_size, queue_props);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600384 EXPECT(err == VK_SUCCESS);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700385
Tony Barbour7ea6aa22015-05-22 09:44:58 -0600386 for (uint32_t i = 0; i < queue_node_count; i++) {
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600387 VkQueue queue;
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700388
Tony Barbour7ea6aa22015-05-22 09:44:58 -0600389 for (uint32_t j = 0; j < queue_props[i].queueCount; j++) {
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500390 // TODO: Need to add support for separate MEMMGR and work queues, including synchronization
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600391 err = vkGetDeviceQueue(obj(), i, j, &queue);
392 EXPECT(err == VK_SUCCESS);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700393
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600394 if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700395 queues_[GRAPHICS].push_back(new Queue(queue));
396 }
397
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600398 if (queue_props[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700399 queues_[COMPUTE].push_back(new Queue(queue));
400 }
401
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600402 if (queue_props[i].queueFlags & VK_QUEUE_DMA_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700403 queues_[DMA].push_back(new Queue(queue));
404 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800405 }
406 }
407
Chris Forbes02038792015-06-04 10:49:27 +1200408 delete[] queue_props;
Tony Barbour3d69c9e2015-05-20 16:53:31 -0600409
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800410 EXPECT(!queues_[GRAPHICS].empty() || !queues_[COMPUTE].empty());
411}
412
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800413void Device::init_formats()
414{
Tony Barbourd1c35722015-04-16 15:59:00 -0600415 for (int f = VK_FORMAT_BEGIN_RANGE; f <= VK_FORMAT_END_RANGE; f++) {
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600416 const VkFormat fmt = static_cast<VkFormat>(f);
417 const VkFormatProperties props = format_properties(fmt);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800418
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700419 if (props.linearTilingFeatures) {
Tony Barbourd1c35722015-04-16 15:59:00 -0600420 const Format tmp = { fmt, VK_IMAGE_TILING_LINEAR, props.linearTilingFeatures };
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700421 formats_.push_back(tmp);
422 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800423
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700424 if (props.optimalTilingFeatures) {
Tony Barbourd1c35722015-04-16 15:59:00 -0600425 const Format tmp = { fmt, VK_IMAGE_TILING_OPTIMAL, props.optimalTilingFeatures };
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700426 formats_.push_back(tmp);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800427 }
428 }
429
430 EXPECT(!formats_.empty());
431}
432
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600433VkFormatProperties Device::format_properties(VkFormat format)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800434{
Tony Barbourd1c35722015-04-16 15:59:00 -0600435 const VkFormatInfoType type = VK_FORMAT_INFO_TYPE_PROPERTIES;
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600436 VkFormatProperties data;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800437 size_t size = sizeof(data);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600438 if (!EXPECT(vkGetFormatInfo(obj(), format, type, &size, &data) == VK_SUCCESS && size == sizeof(data)))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800439 memset(&data, 0, sizeof(data));
440
441 return data;
442}
443
444void Device::wait()
445{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600446 EXPECT(vkDeviceWaitIdle(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800447}
448
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600449VkResult Device::wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800450{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600451 const std::vector<VkFence> fence_objs = make_objects<VkFence>(fences);
452 VkResult err = vkWaitForFences(obj(), fence_objs.size(), &fence_objs[0], wait_all, timeout);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600453 EXPECT(err == VK_SUCCESS || err == VK_TIMEOUT);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800454
455 return err;
456}
457
Chia-I Wu9d00ed72015-05-25 16:27:55 +0800458VkResult Device::update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies)
459{
460 return vkUpdateDescriptorSets(obj(), writes.size(), &writes[0], copies.size(), &copies[0]);
461}
462
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600463void Queue::submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800464{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600465 const std::vector<VkCmdBuffer> cmd_objs = make_objects<VkCmdBuffer>(cmds);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600466 EXPECT(vkQueueSubmit(obj(), cmd_objs.size(), &cmd_objs[0], fence.obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800467}
468
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600469void Queue::submit(const CmdBuffer &cmd, Fence &fence)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800470{
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600471 submit(std::vector<const CmdBuffer*>(1, &cmd), fence);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800472}
473
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600474void Queue::submit(const CmdBuffer &cmd)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800475{
476 Fence fence;
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600477 submit(cmd, fence);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800478}
479
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800480void Queue::wait()
481{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600482 EXPECT(vkQueueWaitIdle(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800483}
484
Courtney Goeltzenleuchterebb95842015-03-25 17:14:29 -0600485void Queue::signal_semaphore(Semaphore &sem)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800486{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600487 EXPECT(vkQueueSignalSemaphore(obj(), sem.obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800488}
489
Courtney Goeltzenleuchterebb95842015-03-25 17:14:29 -0600490void Queue::wait_semaphore(Semaphore &sem)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800491{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600492 EXPECT(vkQueueWaitSemaphore(obj(), sem.obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800493}
494
495GpuMemory::~GpuMemory()
496{
497 if (initialized() && own())
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600498 EXPECT(vkFreeMemory(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800499}
500
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600501void GpuMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800502{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600503 DERIVED_OBJECT_TYPE_INIT(vkAllocMemory, dev, VK_OBJECT_TYPE_DEVICE_MEMORY, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800504}
505
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800506void GpuMemory::init(const Device &dev, size_t size, const void *data)
507{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600508 DERIVED_OBJECT_TYPE_INIT(vkPinSystemMemory, dev, VK_OBJECT_TYPE_DEVICE_MEMORY, data, size);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800509}
510
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600511void GpuMemory::init(const Device &dev, const VkMemoryOpenInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800512{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600513 DERIVED_OBJECT_TYPE_INIT(vkOpenSharedMemory, dev, VK_OBJECT_TYPE_DEVICE_MEMORY, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800514}
515
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600516void GpuMemory::init(const Device &dev, const VkPeerMemoryOpenInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800517{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600518 DERIVED_OBJECT_TYPE_INIT(vkOpenPeerMemory, dev, VK_OBJECT_TYPE_DEVICE_MEMORY, &info);
519}
520
521void GpuMemory::init(const Device &dev, VkDeviceMemory mem)
522{
523 dev_ = &dev;
524 BaseObject::init(mem, VK_OBJECT_TYPE_DEVICE_MEMORY, false);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800525}
526
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600527void GpuMemory::set_priority(VkMemoryPriority priority)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800528{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600529 EXPECT(vkSetMemoryPriority(dev_->obj(), obj(), priority) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800530}
531
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600532const void *GpuMemory::map(VkFlags flags) const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800533{
534 void *data;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600535 if (!EXPECT(vkMapMemory(dev_->obj(), obj(), 0 ,0, flags, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800536 data = NULL;
537
538 return data;
539}
540
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600541void *GpuMemory::map(VkFlags flags)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800542{
543 void *data;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600544 if (!EXPECT(vkMapMemory(dev_->obj(), obj(), 0, 0, flags, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800545 data = NULL;
546
547 return data;
548}
549
550void GpuMemory::unmap() const
551{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600552 EXPECT(vkUnmapMemory(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800553}
554
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600555void Fence::init(const Device &dev, const VkFenceCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800556{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600557 DERIVED_OBJECT_TYPE_INIT(vkCreateFence, dev, VK_OBJECT_TYPE_FENCE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600558 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800559}
560
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600561void Semaphore::init(const Device &dev, const VkSemaphoreCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800562{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600563 DERIVED_OBJECT_TYPE_INIT(vkCreateSemaphore, dev, VK_OBJECT_TYPE_SEMAPHORE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600564 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800565}
566
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600567void Semaphore::init(const Device &dev, const VkSemaphoreOpenInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800568{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600569 DERIVED_OBJECT_TYPE_INIT(vkOpenSharedSemaphore, dev, VK_OBJECT_TYPE_SEMAPHORE, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800570}
571
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600572void Event::init(const Device &dev, const VkEventCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800573{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600574 DERIVED_OBJECT_TYPE_INIT(vkCreateEvent, dev, VK_OBJECT_TYPE_EVENT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600575 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800576}
577
578void Event::set()
579{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600580 EXPECT(vkSetEvent(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800581}
582
583void Event::reset()
584{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600585 EXPECT(vkResetEvent(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800586}
587
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600588void QueryPool::init(const Device &dev, const VkQueryPoolCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800589{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600590 DERIVED_OBJECT_TYPE_INIT(vkCreateQueryPool, dev, VK_OBJECT_TYPE_QUERY_POOL, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600591 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800592}
593
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600594VkResult QueryPool::results(uint32_t start, uint32_t count, size_t size, void *data)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800595{
596 size_t tmp = size;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600597 VkResult err = vkGetQueryPoolResults(dev_->obj(), obj(), start, count, &tmp, data, 0);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600598 if (err == VK_SUCCESS) {
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800599 if (!EXPECT(tmp == size))
600 memset(data, 0, size);
601 } else {
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600602 EXPECT(err == VK_NOT_READY);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800603 }
604
605 return err;
606}
607
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600608void Buffer::init(const Device &dev, const VkBufferCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800609{
610 init_no_mem(dev, info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600611 alloc_memory();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800612}
613
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600614void Buffer::init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags &reqs)
615{
616 init_no_mem(dev, info);
617 alloc_memory(reqs);
618}
619
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600620void Buffer::init_no_mem(const Device &dev, const VkBufferCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800621{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600622 DERIVED_OBJECT_TYPE_INIT(vkCreateBuffer, dev, VK_OBJECT_TYPE_BUFFER, &info);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800623 create_info_ = info;
624}
625
Mark Lobodzinski23065352015-05-29 09:32:35 -0500626void Buffer::bind_memory(VkDeviceSize offset, VkDeviceSize size,
Mark Lobodzinski942b1722015-05-11 17:21:15 -0500627 const GpuMemory &mem, VkDeviceSize mem_offset)
628{
629 VkQueue queue = dev_->graphics_queues()[0]->obj();
Mark Lobodzinski23065352015-05-29 09:32:35 -0500630 EXPECT(vkQueueBindSparseBufferMemory(queue, obj(), offset, size, mem.obj(), mem_offset) == VK_SUCCESS);
Mark Lobodzinski942b1722015-05-11 17:21:15 -0500631}
632
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600633void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800634{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600635 DERIVED_OBJECT_TYPE_INIT(vkCreateBufferView, dev, VK_OBJECT_TYPE_BUFFER_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600636 alloc_memory();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800637}
638
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600639void Image::init(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800640{
641 init_no_mem(dev, info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600642 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800643}
644
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600645void Image::init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags &reqs)
646{
647 init_no_mem(dev, info);
648 alloc_memory(reqs);
649}
650
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600651void Image::init_no_mem(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800652{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600653 DERIVED_OBJECT_TYPE_INIT(vkCreateImage, dev, VK_OBJECT_TYPE_IMAGE, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800654 init_info(dev, info);
655}
656
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600657void Image::init(const Device &dev, const VkPeerImageOpenInfo &info, const VkImageCreateInfo &original_info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800658{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600659 VkImage img;
Tony Barbourd1c35722015-04-16 15:59:00 -0600660 VkDeviceMemory mem;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600661 dev_ = &dev;
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600662 EXPECT(vkOpenPeerImage(dev.obj(), &info, &img, &mem) == VK_SUCCESS);
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600663 Object::init(img, VK_OBJECT_TYPE_IMAGE);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800664
665 init_info(dev, original_info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600666 alloc_memory(std::vector<VkDeviceMemory>(1, mem));
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800667}
668
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600669void Image::init_info(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800670{
671 create_info_ = info;
672
673 for (std::vector<Device::Format>::const_iterator it = dev.formats().begin(); it != dev.formats().end(); it++) {
674 if (memcmp(&it->format, &create_info_.format, sizeof(it->format)) == 0 && it->tiling == create_info_.tiling) {
675 format_features_ = it->features;
676 break;
677 }
678 }
679}
680
Mark Lobodzinski23065352015-05-29 09:32:35 -0500681void Image::bind_memory(const Device &dev, const VkImageMemoryBindInfo &info,
Tony Barbourd1c35722015-04-16 15:59:00 -0600682 const GpuMemory &mem, VkDeviceSize mem_offset)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800683{
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500684 VkQueue queue = dev.graphics_queues()[0]->obj();
Mark Lobodzinski23065352015-05-29 09:32:35 -0500685 EXPECT(vkQueueBindSparseImageMemory(queue, obj(), &info, mem.obj(), mem_offset) == VK_SUCCESS);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800686}
687
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600688VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800689{
Tony Barbourd1c35722015-04-16 15:59:00 -0600690 const VkSubresourceInfoType type = VK_SUBRESOURCE_INFO_TYPE_LAYOUT;
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600691 VkSubresourceLayout data;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800692 size_t size = sizeof(data);
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600693 if (!EXPECT(vkGetImageSubresourceInfo(dev_->obj(), obj(), &subres, type, &size, &data) == VK_SUCCESS && size == sizeof(data)))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800694 memset(&data, 0, sizeof(data));
695
696 return data;
697}
698
699bool Image::transparent() const
700{
Tony Barbourd1c35722015-04-16 15:59:00 -0600701 return (create_info_.tiling == VK_IMAGE_TILING_LINEAR &&
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800702 create_info_.samples == 1 &&
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600703 !(create_info_.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
704 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)));
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800705}
706
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600707void ImageView::init(const Device &dev, const VkImageViewCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800708{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600709 DERIVED_OBJECT_TYPE_INIT(vkCreateImageView, dev, VK_OBJECT_TYPE_IMAGE_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600710 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800711}
712
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600713void ColorAttachmentView::init(const Device &dev, const VkColorAttachmentViewCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800714{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600715 DERIVED_OBJECT_TYPE_INIT(vkCreateColorAttachmentView, dev, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600716 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800717}
718
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600719void DepthStencilView::init(const Device &dev, const VkDepthStencilViewCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800720{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600721 DERIVED_OBJECT_TYPE_INIT(vkCreateDepthStencilView, dev, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600722 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800723}
724
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600725void Shader::init(const Device &dev, const VkShaderCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800726{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600727 DERIVED_OBJECT_TYPE_INIT(vkCreateShader, dev, VK_OBJECT_TYPE_SHADER, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800728}
729
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600730VkResult Shader::init_try(const Device &dev, const VkShaderCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800731{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600732 /*
733 * Note: Cannot use DERIVED_OBJECT_TYPE_INIT as we need the
734 * return code.
735 */
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600736 VkShader sh;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600737 dev_ = &dev;
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600738 VkResult err = vkCreateShader(dev.obj(), &info, &sh);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600739 if (err == VK_SUCCESS)
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600740 Object::init(sh, VK_OBJECT_TYPE_SHADER);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800741
742 return err;
743}
744
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600745void Pipeline::init(const Device &dev, const VkGraphicsPipelineCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800746{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600747 DERIVED_OBJECT_TYPE_INIT(vkCreateGraphicsPipeline, dev, VK_OBJECT_TYPE_PIPELINE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600748 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800749}
750
Chris Forbes95292b12015-05-25 11:13:26 +1200751VkResult Pipeline::init_try(const Device &dev, const VkGraphicsPipelineCreateInfo &info)
752{
753 VkPipeline pipe;
754 dev_ = &dev;
755 VkResult err = vkCreateGraphicsPipeline(dev.obj(), &info, &pipe);
756 if (err == VK_SUCCESS) {
757 Object::init(pipe, VK_OBJECT_TYPE_PIPELINE);
758 alloc_memory();
759 }
760
761 return err;
762}
763
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600764void Pipeline::init(
765 const Device &dev,
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600766 const VkGraphicsPipelineCreateInfo &info,
767 const VkPipeline basePipeline)
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600768{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600769 DERIVED_OBJECT_TYPE_INIT(vkCreateGraphicsPipelineDerivative, dev, VK_OBJECT_TYPE_PIPELINE, &info, basePipeline);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600770 alloc_memory();
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600771}
772
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600773void Pipeline::init(const Device &dev, const VkComputePipelineCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800774{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600775 DERIVED_OBJECT_TYPE_INIT(vkCreateComputePipeline, dev, VK_OBJECT_TYPE_PIPELINE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600776 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800777}
778
779void Pipeline::init(const Device&dev, size_t size, const void *data)
780{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600781 DERIVED_OBJECT_TYPE_INIT(vkLoadPipeline, dev, VK_OBJECT_TYPE_PIPELINE, size, data);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600782 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800783}
784
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600785void Pipeline::init(
786 const Device&dev,
787 size_t size,
788 const void *data,
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600789 const VkPipeline basePipeline)
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600790{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600791 DERIVED_OBJECT_TYPE_INIT(vkLoadPipelineDerivative, dev, VK_OBJECT_TYPE_PIPELINE, size, data, basePipeline);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600792 alloc_memory();
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600793}
794
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800795size_t Pipeline::store(size_t size, void *data)
796{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600797 if (!EXPECT(vkStorePipeline(dev_->obj(), obj(), &size, data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800798 size = 0;
799
800 return size;
801}
802
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600803void Sampler::init(const Device &dev, const VkSamplerCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800804{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600805 DERIVED_OBJECT_TYPE_INIT(vkCreateSampler, dev, VK_OBJECT_TYPE_SAMPLER, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600806 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800807}
808
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600809void DescriptorSetLayout::init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800810{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600811 DERIVED_OBJECT_TYPE_INIT(vkCreateDescriptorSetLayout, dev, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600812 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800813}
814
Mark Lobodzinski0fadf5f2015-04-17 14:11:39 -0500815void PipelineLayout::init(const Device &dev, VkPipelineLayoutCreateInfo &info, const std::vector<const DescriptorSetLayout *> &layouts)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800816{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600817 const std::vector<VkDescriptorSetLayout> layout_objs = make_objects<VkDescriptorSetLayout>(layouts);
Mark Lobodzinski0fadf5f2015-04-17 14:11:39 -0500818 info.pSetLayouts = &layout_objs[0];
Chia-I Wu41126e52015-03-26 15:27:55 +0800819
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600820 DERIVED_OBJECT_TYPE_INIT(vkCreatePipelineLayout, dev, VK_OBJECT_TYPE_PIPELINE_LAYOUT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600821 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800822}
823
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600824void DescriptorPool::init(const Device &dev, VkDescriptorPoolUsage usage,
825 uint32_t max_sets, const VkDescriptorPoolCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800826{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600827 DERIVED_OBJECT_TYPE_INIT(vkCreateDescriptorPool, dev, VK_OBJECT_TYPE_DESCRIPTOR_POOL, usage, max_sets, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600828 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800829}
830
Chia-I Wufae40bc2015-03-26 15:23:52 +0800831void DescriptorPool::reset()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800832{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600833 EXPECT(vkResetDescriptorPool(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800834}
835
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500836std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const std::vector<const DescriptorSetLayout *> &layouts)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800837{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600838 const std::vector<VkDescriptorSetLayout> layout_objs = make_objects<VkDescriptorSetLayout>(layouts);
Chia-I Wu11078b02015-01-04 16:27:24 +0800839
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600840 std::vector<VkDescriptorSet> set_objs;
Chia-I Wu11078b02015-01-04 16:27:24 +0800841 set_objs.resize(layout_objs.size());
842
843 uint32_t set_count;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600844 VkResult err = vkAllocDescriptorSets(dev_->obj(), obj(), usage, layout_objs.size(), &layout_objs[0], &set_objs[0], &set_count);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600845 if (err == VK_SUCCESS)
Chia-I Wu11078b02015-01-04 16:27:24 +0800846 EXPECT(set_count == set_objs.size());
847 set_objs.resize(set_count);
848
849 std::vector<DescriptorSet *> sets;
850 sets.reserve(set_count);
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600851 for (std::vector<VkDescriptorSet>::const_iterator it = set_objs.begin(); it != set_objs.end(); it++) {
Chia-I Wu11078b02015-01-04 16:27:24 +0800852 // do descriptor sets need memories bound?
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600853 DescriptorSet *descriptorSet = new DescriptorSet(dev, *it);
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500854 sets.push_back(descriptorSet);
Chia-I Wu11078b02015-01-04 16:27:24 +0800855 }
Chia-I Wu11078b02015-01-04 16:27:24 +0800856 return sets;
857}
858
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500859std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout, uint32_t count)
Chia-I Wu11078b02015-01-04 16:27:24 +0800860{
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500861 return alloc_sets(dev, usage, std::vector<const DescriptorSetLayout *>(count, &layout));
Chia-I Wu11078b02015-01-04 16:27:24 +0800862}
863
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500864DescriptorSet *DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout)
Chia-I Wu11078b02015-01-04 16:27:24 +0800865{
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500866 std::vector<DescriptorSet *> set = alloc_sets(dev, usage, layout, 1);
Chia-I Wu11078b02015-01-04 16:27:24 +0800867 return (set.empty()) ? NULL : set[0];
868}
869
Chia-I Wu985ba162015-03-26 13:14:16 +0800870void DescriptorPool::clear_sets(const std::vector<DescriptorSet *> &sets)
Chia-I Wu11078b02015-01-04 16:27:24 +0800871{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600872 const std::vector<VkDescriptorSet> set_objs = make_objects<VkDescriptorSet>(sets);
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600873 vkClearDescriptorSets(dev_->obj(), obj(), set_objs.size(), &set_objs[0]);
Chia-I Wu11078b02015-01-04 16:27:24 +0800874}
875
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600876void DynamicVpStateObject::init(const Device &dev, const VkDynamicVpStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800877{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600878 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicViewportState, dev, VK_OBJECT_TYPE_DYNAMIC_VP_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600879 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800880}
881
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600882void DynamicRsStateObject::init(const Device &dev, const VkDynamicRsStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800883{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600884 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicRasterState, dev, VK_OBJECT_TYPE_DYNAMIC_RS_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600885 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800886}
887
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600888void DynamicCbStateObject::init(const Device &dev, const VkDynamicCbStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800889{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600890 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicColorBlendState, dev, VK_OBJECT_TYPE_DYNAMIC_CB_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600891 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800892}
893
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600894void DynamicDsStateObject::init(const Device &dev, const VkDynamicDsStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800895{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600896 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicDepthStencilState, dev, VK_OBJECT_TYPE_DYNAMIC_DS_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600897 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800898}
899
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600900void CmdBuffer::init(const Device &dev, const VkCmdBufferCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800901{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600902 DERIVED_OBJECT_TYPE_INIT(vkCreateCommandBuffer, dev, VK_OBJECT_TYPE_COMMAND_BUFFER, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800903}
904
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600905void CmdBuffer::begin(const VkCmdBufferBeginInfo *info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800906{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600907 EXPECT(vkBeginCommandBuffer(obj(), info) == VK_SUCCESS);
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700908}
909
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600910void CmdBuffer::begin(VkRenderPass renderpass_obj, VkFramebuffer framebuffer_obj)
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700911{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600912 VkCmdBufferBeginInfo info = {};
913 VkCmdBufferGraphicsBeginInfo graphics_cmd_buf_info = {};
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600914 graphics_cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
Tony Barbourbdf0a312015-04-01 17:10:07 -0600915 graphics_cmd_buf_info.pNext = NULL;
Courtney Goeltzenleuchter69894b72015-04-03 15:25:24 -0600916 graphics_cmd_buf_info.renderPassContinue.renderPass = renderpass_obj;
917 graphics_cmd_buf_info.renderPassContinue.framebuffer = framebuffer_obj;
Tony Barbourbdf0a312015-04-01 17:10:07 -0600918
Tony Barbourd1c35722015-04-16 15:59:00 -0600919 info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600920 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
921 info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700922 info.pNext = &graphics_cmd_buf_info;
923
924 begin(&info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800925}
926
927void CmdBuffer::begin()
928{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600929 VkCmdBufferBeginInfo info = {};
Tony Barbourd1c35722015-04-16 15:59:00 -0600930 info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600931 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
932 info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700933
934 begin(&info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800935}
936
937void CmdBuffer::end()
938{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600939 EXPECT(vkEndCommandBuffer(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800940}
941
942void CmdBuffer::reset()
943{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600944 EXPECT(vkResetCommandBuffer(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800945}
946
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600947}; // namespace vk_testing