blob: 8579b7eda472e85eb5552de01f654f9bf7013cb7 [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
129std::vector<const char *> PhysicalGpu::layers(std::vector<char> &buf) const
130{
131 const size_t max_layer_count = 16;
132 const size_t max_string_size = 256;
133
134 buf.resize(max_layer_count * max_string_size);
135
136 std::vector<const char *> layers;
137 layers.reserve(max_layer_count);
138 for (size_t i = 0; i < max_layer_count; i++)
139 layers.push_back(&buf[0] + max_string_size * i);
140
141 char * const *out = const_cast<char * const *>(&layers[0]);
Courtney Goeltzenleuchterd9dc0c72015-04-20 11:04:54 -0600142 size_t count = max_layer_count; /* allow up to 16 layer names to be returned */
143 if (!EXPECT(vkEnumerateLayers(gpu_, max_string_size, &count, out, NULL) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800144 count = 0;
145 layers.resize(count);
146
147 return layers;
148}
149
150std::vector<const char *> PhysicalGpu::extensions() const
151{
Tobin Ehlis9430c782015-04-16 18:04:57 -0600152 // Extensions to enable
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800153 static const char *known_exts[] = {
Chia-I Wuf8693382015-04-16 22:02:10 +0800154 "VK_WSI_LunarG",
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800155 };
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800156 std::vector<const char *> exts;
Tobin Ehlis9430c782015-04-16 18:04:57 -0600157 size_t extSize = sizeof(uint32_t);
158 uint32_t extCount = 0;
159 if (!EXPECT(vkGetGlobalExtensionInfo(VK_EXTENSION_INFO_TYPE_COUNT, 0, &extSize, &extCount) == VK_SUCCESS))
160 return exts;
161
162 VkExtensionProperties extProp;
163 extSize = sizeof(VkExtensionProperties);
164 // TODO : Need to update this if/when we have more than 1 extension to enable
165 for (uint32_t i = 0; i < extCount; i++) {
166 if (!EXPECT(vkGetGlobalExtensionInfo(VK_EXTENSION_INFO_TYPE_PROPERTIES, i, &extSize, &extProp) == VK_SUCCESS))
167 return exts;
168
169 if (!strcmp(known_exts[0], extProp.extName))
170 exts.push_back(known_exts[i]);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800171 }
172
173 return exts;
174}
175
Tony Barbourd1c35722015-04-16 15:59:00 -0600176VkPhysicalDeviceCompatibilityInfo PhysicalGpu::compatibility(const PhysicalGpu &other) const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800177{
Tony Barbourd1c35722015-04-16 15:59:00 -0600178 VkPhysicalDeviceCompatibilityInfo data;
179 if (!EXPECT(vkGetMultiDeviceCompatibility(gpu_, other.gpu_, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800180 memset(&data, 0, sizeof(data));
181
182 return data;
183}
184
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600185void BaseObject::init(VkObject obj, VkObjectType type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800186{
187 EXPECT(!initialized());
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600188 reinit(obj, type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800189}
190
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600191void BaseObject::reinit(VkObject obj, VkObjectType type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800192{
193 obj_ = obj;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600194 object_type_ = type;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800195 own_obj_ = own;
196}
197
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600198uint32_t Object::memory_allocation_count() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800199{
Mark Lobodzinski23065352015-05-29 09:32:35 -0500200 /// LUGMAL return get_info<uint32_t>(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, 1)[0];
201 return 1;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800202}
203
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600204std::vector<VkMemoryRequirements> Object::memory_requirements() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800205{
Mark Lobodzinski23065352015-05-29 09:32:35 -0500206 //// VkResult err;
207 uint32_t num_allocations = 1;
208 //// size_t num_alloc_size = sizeof(num_allocations);
209 //// err = vkGetObjectInfo(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
210 //// &num_alloc_size, &num_allocations);
211 //// EXPECT(err == VK_SUCCESS && num_alloc_size == sizeof(num_allocations));
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600212 std::vector<VkMemoryRequirements> info =
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600213 get_info<VkMemoryRequirements>(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, 0);
Jon Ashburn7e781952015-01-16 09:37:43 -0700214 EXPECT(info.size() == num_allocations);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800215 if (info.size() == 1 && !info[0].size)
216 info.clear();
217
218 return info;
219}
220
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600221void Object::init(VkObject obj, VkObjectType object_type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800222{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600223 BaseObject::init(obj, object_type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800224 mem_alloc_count_ = memory_allocation_count();
225}
226
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600227void Object::reinit(VkObject obj, VkObjectType object_type, bool own)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800228{
229 cleanup();
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600230 BaseObject::reinit(obj, object_type, own);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800231 mem_alloc_count_ = memory_allocation_count();
232}
233
234void Object::cleanup()
235{
236 if (!initialized())
237 return;
238
Tony Barbour44bb3ab2015-04-09 16:00:18 -0600239 if(bound) {
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600240 unbind_memory();
Tony Barbour44bb3ab2015-04-09 16:00:18 -0600241 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800242
243 if (internal_mems_) {
244 delete[] internal_mems_;
245 internal_mems_ = NULL;
246 primary_mem_ = NULL;
247 }
248
249 mem_alloc_count_ = 0;
250
251 if (own())
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600252 EXPECT(vkDestroyObject(dev_->obj(), type(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800253}
254
Mark Lobodzinski23065352015-05-29 09:32:35 -0500255void Object::bind_memory(const GpuMemory &mem, VkDeviceSize mem_offset)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800256{
Tony Barbour44bb3ab2015-04-09 16:00:18 -0600257 bound = true;
Mark Lobodzinski23065352015-05-29 09:32:35 -0500258 EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), mem.obj(), mem_offset) == VK_SUCCESS);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800259}
260
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800261
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600262void Object::unbind_memory()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800263{
Mark Lobodzinski23065352015-05-29 09:32:35 -0500264 EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), VK_NULL_HANDLE, 0) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800265}
266
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600267void Object::alloc_memory()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800268{
269 if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
270 return;
271
272 internal_mems_ = new GpuMemory[mem_alloc_count_];
273
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600274 const std::vector<VkMemoryRequirements> mem_reqs = memory_requirements();
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600275 VkMemoryAllocInfo info, *next_info = NULL;
Jon Ashburn8a5da752015-01-19 15:00:26 -0700276
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800277 for (int i = 0; i < mem_reqs.size(); i++) {
Jon Ashburn25bbe462015-01-20 08:50:12 -0700278 info = GpuMemory::alloc_info(mem_reqs[i], next_info);
Mark Lobodzinskie39f6952015-04-16 08:52:00 -0500279 primary_mem_ = &internal_mems_[i];
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600280 internal_mems_[i].init(*dev_, info);
Mark Lobodzinski23065352015-05-29 09:32:35 -0500281 bind_memory(internal_mems_[i], 0);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800282 }
283}
284
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600285void Object::alloc_memory(VkMemoryPropertyFlags &reqs)
286{
287 if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
288 return;
289
290 internal_mems_ = new GpuMemory[mem_alloc_count_];
291
292 std::vector<VkMemoryRequirements> mem_reqs = memory_requirements();
293 VkMemoryAllocInfo info, *next_info = NULL;
294
295 for (int i = 0; i < mem_reqs.size(); i++) {
296 mem_reqs[i].memPropsRequired |= reqs;
297 info = GpuMemory::alloc_info(mem_reqs[i], next_info);
298 primary_mem_ = &internal_mems_[i];
299 internal_mems_[i].init(*dev_, info);
Mark Lobodzinski23065352015-05-29 09:32:35 -0500300 bind_memory(internal_mems_[i], 0);
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600301 }
302}
303
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600304void Object::alloc_memory(const std::vector<VkDeviceMemory> &mems)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800305{
306 if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
307 return;
308
309 internal_mems_ = new GpuMemory[mem_alloc_count_];
310
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600311 const std::vector<VkMemoryRequirements> mem_reqs = memory_requirements();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800312 if (!EXPECT(mem_reqs.size() == mems.size()))
313 return;
314
315 for (int i = 0; i < mem_reqs.size(); i++) {
316 primary_mem_ = &internal_mems_[i];
317
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600318 internal_mems_[i].init(*dev_, mems[i]);
Mark Lobodzinski23065352015-05-29 09:32:35 -0500319 bind_memory(internal_mems_[i], 0);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800320 }
321}
322
Tony Barbourd1c35722015-04-16 15:59:00 -0600323std::vector<VkDeviceMemory> Object::memories() const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800324{
Tony Barbourd1c35722015-04-16 15:59:00 -0600325 std::vector<VkDeviceMemory> mems;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800326 if (internal_mems_) {
327 mems.reserve(mem_alloc_count_);
328 for (uint32_t i = 0; i < mem_alloc_count_; i++)
329 mems.push_back(internal_mems_[i].obj());
330 }
331
332 return mems;
333}
334
335Device::~Device()
336{
337 if (!initialized())
338 return;
339
340 for (int i = 0; i < QUEUE_COUNT; i++) {
341 for (std::vector<Queue *>::iterator it = queues_[i].begin(); it != queues_[i].end(); it++)
342 delete *it;
343 queues_[i].clear();
344 }
345
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600346 EXPECT(vkDestroyDevice(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800347}
348
Chia-I Wu510c9992015-01-06 10:40:45 +0800349void Device::init(bool enable_layers)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800350{
351 // request all queues
Tony Barbourd1c35722015-04-16 15:59:00 -0600352 const std::vector<VkPhysicalDeviceQueueProperties> queue_props = gpu_.queue_properties();
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600353 std::vector<VkDeviceQueueCreateInfo> queue_info;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800354 queue_info.reserve(queue_props.size());
355 for (int i = 0; i < queue_props.size(); i++) {
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600356 VkDeviceQueueCreateInfo qi = {};
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800357 qi.queueNodeIndex = i;
358 qi.queueCount = queue_props[i].queueCount;
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600359 if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700360 graphics_queue_node_index_ = i;
361 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800362 queue_info.push_back(qi);
363 }
364
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600365 VkLayerCreateInfo layer_info = {};
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600366 layer_info.sType = VK_STRUCTURE_TYPE_LAYER_CREATE_INFO;
Chia-I Wu510c9992015-01-06 10:40:45 +0800367
368 std::vector<const char *> layers;
369 std::vector<char> layer_buf;
370 // request all layers
371 if (enable_layers) {
372 layers = gpu_.layers(layer_buf);
373 layer_info.layerCount = layers.size();
374 layer_info.ppActiveLayerNames = &layers[0];
375 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800376
377 const std::vector<const char *> exts = gpu_.extensions();
378
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600379 VkDeviceCreateInfo dev_info = {};
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600380 dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
Jon Ashburnf7e282a2015-01-22 13:33:15 -0700381 dev_info.pNext = (enable_layers) ? static_cast<void *>(&layer_info) : NULL;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800382 dev_info.queueRecordCount = queue_info.size();
383 dev_info.pRequestedQueues = &queue_info[0];
384 dev_info.extensionCount = exts.size();
385 dev_info.ppEnabledExtensionNames = &exts[0];
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600386 dev_info.flags = VK_DEVICE_CREATE_VALIDATION_BIT;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800387
388 init(dev_info);
389}
390
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600391void Device::init(const VkDeviceCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800392{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600393 VkDevice obj;
394 if (EXPECT(vkCreateDevice(gpu_.obj(), &info, &obj) == VK_SUCCESS)) {
395 base_type::init(obj, VK_OBJECT_TYPE_DEVICE);
396 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800397
398 init_queues();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800399 init_formats();
400}
401
402void Device::init_queues()
403{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600404 VkResult err;
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700405 size_t data_size;
406 uint32_t queue_node_count;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800407
Tony Barbourd1c35722015-04-16 15:59:00 -0600408 err = vkGetPhysicalDeviceInfo(gpu_.obj(), VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES,
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700409 &data_size, NULL);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600410 EXPECT(err == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800411
Tony Barbourd1c35722015-04-16 15:59:00 -0600412 queue_node_count = data_size / sizeof(VkPhysicalDeviceQueueProperties);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700413 EXPECT(queue_node_count >= 1);
414
Tony Barbourd1c35722015-04-16 15:59:00 -0600415 VkPhysicalDeviceQueueProperties queue_props[queue_node_count];
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700416
Tony Barbourd1c35722015-04-16 15:59:00 -0600417 err = vkGetPhysicalDeviceInfo(gpu_.obj(), VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES,
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700418 &data_size, queue_props);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600419 EXPECT(err == VK_SUCCESS);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700420
421 for (int i = 0; i < queue_node_count; i++) {
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600422 VkQueue queue;
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700423
424 for (int j = 0; j < queue_props[i].queueCount; j++) {
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500425 // TODO: Need to add support for separate MEMMGR and work queues, including synchronization
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600426 err = vkGetDeviceQueue(obj(), i, j, &queue);
427 EXPECT(err == VK_SUCCESS);
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700428
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600429 if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700430 queues_[GRAPHICS].push_back(new Queue(queue));
431 }
432
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600433 if (queue_props[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700434 queues_[COMPUTE].push_back(new Queue(queue));
435 }
436
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600437 if (queue_props[i].queueFlags & VK_QUEUE_DMA_BIT) {
Courtney Goeltzenleuchter18248e62015-03-05 18:09:39 -0700438 queues_[DMA].push_back(new Queue(queue));
439 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800440 }
441 }
442
443 EXPECT(!queues_[GRAPHICS].empty() || !queues_[COMPUTE].empty());
444}
445
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800446void Device::init_formats()
447{
Tony Barbourd1c35722015-04-16 15:59:00 -0600448 for (int f = VK_FORMAT_BEGIN_RANGE; f <= VK_FORMAT_END_RANGE; f++) {
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600449 const VkFormat fmt = static_cast<VkFormat>(f);
450 const VkFormatProperties props = format_properties(fmt);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800451
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700452 if (props.linearTilingFeatures) {
Tony Barbourd1c35722015-04-16 15:59:00 -0600453 const Format tmp = { fmt, VK_IMAGE_TILING_LINEAR, props.linearTilingFeatures };
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700454 formats_.push_back(tmp);
455 }
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800456
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700457 if (props.optimalTilingFeatures) {
Tony Barbourd1c35722015-04-16 15:59:00 -0600458 const Format tmp = { fmt, VK_IMAGE_TILING_OPTIMAL, props.optimalTilingFeatures };
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700459 formats_.push_back(tmp);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800460 }
461 }
462
463 EXPECT(!formats_.empty());
464}
465
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600466VkFormatProperties Device::format_properties(VkFormat format)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800467{
Tony Barbourd1c35722015-04-16 15:59:00 -0600468 const VkFormatInfoType type = VK_FORMAT_INFO_TYPE_PROPERTIES;
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600469 VkFormatProperties data;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800470 size_t size = sizeof(data);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600471 if (!EXPECT(vkGetFormatInfo(obj(), format, type, &size, &data) == VK_SUCCESS && size == sizeof(data)))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800472 memset(&data, 0, sizeof(data));
473
474 return data;
475}
476
477void Device::wait()
478{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600479 EXPECT(vkDeviceWaitIdle(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800480}
481
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600482VkResult Device::wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800483{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600484 const std::vector<VkFence> fence_objs = make_objects<VkFence>(fences);
485 VkResult err = vkWaitForFences(obj(), fence_objs.size(), &fence_objs[0], wait_all, timeout);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600486 EXPECT(err == VK_SUCCESS || err == VK_TIMEOUT);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800487
488 return err;
489}
490
Chia-I Wu9d00ed72015-05-25 16:27:55 +0800491VkResult Device::update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes, const std::vector<VkCopyDescriptorSet> &copies)
492{
493 return vkUpdateDescriptorSets(obj(), writes.size(), &writes[0], copies.size(), &copies[0]);
494}
495
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600496void Queue::submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800497{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600498 const std::vector<VkCmdBuffer> cmd_objs = make_objects<VkCmdBuffer>(cmds);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600499 EXPECT(vkQueueSubmit(obj(), cmd_objs.size(), &cmd_objs[0], fence.obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800500}
501
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600502void Queue::submit(const CmdBuffer &cmd, Fence &fence)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800503{
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600504 submit(std::vector<const CmdBuffer*>(1, &cmd), fence);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800505}
506
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600507void Queue::submit(const CmdBuffer &cmd)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800508{
509 Fence fence;
Courtney Goeltzenleuchter97b75232015-04-07 17:13:38 -0600510 submit(cmd, fence);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800511}
512
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800513void Queue::wait()
514{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600515 EXPECT(vkQueueWaitIdle(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800516}
517
Courtney Goeltzenleuchterebb95842015-03-25 17:14:29 -0600518void Queue::signal_semaphore(Semaphore &sem)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800519{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600520 EXPECT(vkQueueSignalSemaphore(obj(), sem.obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800521}
522
Courtney Goeltzenleuchterebb95842015-03-25 17:14:29 -0600523void Queue::wait_semaphore(Semaphore &sem)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800524{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600525 EXPECT(vkQueueWaitSemaphore(obj(), sem.obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800526}
527
528GpuMemory::~GpuMemory()
529{
530 if (initialized() && own())
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600531 EXPECT(vkFreeMemory(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800532}
533
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600534void GpuMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800535{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600536 DERIVED_OBJECT_TYPE_INIT(vkAllocMemory, dev, VK_OBJECT_TYPE_DEVICE_MEMORY, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800537}
538
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800539void GpuMemory::init(const Device &dev, size_t size, const void *data)
540{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600541 DERIVED_OBJECT_TYPE_INIT(vkPinSystemMemory, dev, VK_OBJECT_TYPE_DEVICE_MEMORY, data, size);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800542}
543
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600544void GpuMemory::init(const Device &dev, const VkMemoryOpenInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800545{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600546 DERIVED_OBJECT_TYPE_INIT(vkOpenSharedMemory, dev, VK_OBJECT_TYPE_DEVICE_MEMORY, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800547}
548
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600549void GpuMemory::init(const Device &dev, const VkPeerMemoryOpenInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800550{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600551 DERIVED_OBJECT_TYPE_INIT(vkOpenPeerMemory, dev, VK_OBJECT_TYPE_DEVICE_MEMORY, &info);
552}
553
554void GpuMemory::init(const Device &dev, VkDeviceMemory mem)
555{
556 dev_ = &dev;
557 BaseObject::init(mem, VK_OBJECT_TYPE_DEVICE_MEMORY, false);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800558}
559
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600560void GpuMemory::set_priority(VkMemoryPriority priority)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800561{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600562 EXPECT(vkSetMemoryPriority(dev_->obj(), obj(), priority) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800563}
564
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600565const void *GpuMemory::map(VkFlags flags) const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800566{
567 void *data;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600568 if (!EXPECT(vkMapMemory(dev_->obj(), obj(), 0 ,0, flags, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800569 data = NULL;
570
571 return data;
572}
573
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600574void *GpuMemory::map(VkFlags flags)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800575{
576 void *data;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600577 if (!EXPECT(vkMapMemory(dev_->obj(), obj(), 0, 0, flags, &data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800578 data = NULL;
579
580 return data;
581}
582
583void GpuMemory::unmap() const
584{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600585 EXPECT(vkUnmapMemory(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800586}
587
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600588void Fence::init(const Device &dev, const VkFenceCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800589{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600590 DERIVED_OBJECT_TYPE_INIT(vkCreateFence, dev, VK_OBJECT_TYPE_FENCE, &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 -0600594void Semaphore::init(const Device &dev, const VkSemaphoreCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800595{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600596 DERIVED_OBJECT_TYPE_INIT(vkCreateSemaphore, dev, VK_OBJECT_TYPE_SEMAPHORE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600597 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800598}
599
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600600void Semaphore::init(const Device &dev, const VkSemaphoreOpenInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800601{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600602 DERIVED_OBJECT_TYPE_INIT(vkOpenSharedSemaphore, dev, VK_OBJECT_TYPE_SEMAPHORE, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800603}
604
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600605void Event::init(const Device &dev, const VkEventCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800606{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600607 DERIVED_OBJECT_TYPE_INIT(vkCreateEvent, dev, VK_OBJECT_TYPE_EVENT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600608 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800609}
610
611void Event::set()
612{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600613 EXPECT(vkSetEvent(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800614}
615
616void Event::reset()
617{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600618 EXPECT(vkResetEvent(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800619}
620
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600621void QueryPool::init(const Device &dev, const VkQueryPoolCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800622{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600623 DERIVED_OBJECT_TYPE_INIT(vkCreateQueryPool, dev, VK_OBJECT_TYPE_QUERY_POOL, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600624 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800625}
626
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600627VkResult QueryPool::results(uint32_t start, uint32_t count, size_t size, void *data)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800628{
629 size_t tmp = size;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600630 VkResult err = vkGetQueryPoolResults(dev_->obj(), obj(), start, count, &tmp, data, 0);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600631 if (err == VK_SUCCESS) {
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800632 if (!EXPECT(tmp == size))
633 memset(data, 0, size);
634 } else {
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600635 EXPECT(err == VK_NOT_READY);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800636 }
637
638 return err;
639}
640
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600641void Buffer::init(const Device &dev, const VkBufferCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800642{
643 init_no_mem(dev, info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600644 alloc_memory();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800645}
646
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600647void Buffer::init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags &reqs)
648{
649 init_no_mem(dev, info);
650 alloc_memory(reqs);
651}
652
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600653void Buffer::init_no_mem(const Device &dev, const VkBufferCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800654{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600655 DERIVED_OBJECT_TYPE_INIT(vkCreateBuffer, dev, VK_OBJECT_TYPE_BUFFER, &info);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800656 create_info_ = info;
657}
658
Mark Lobodzinski23065352015-05-29 09:32:35 -0500659void Buffer::bind_memory(VkDeviceSize offset, VkDeviceSize size,
Mark Lobodzinski942b1722015-05-11 17:21:15 -0500660 const GpuMemory &mem, VkDeviceSize mem_offset)
661{
662 VkQueue queue = dev_->graphics_queues()[0]->obj();
Mark Lobodzinski23065352015-05-29 09:32:35 -0500663 EXPECT(vkQueueBindSparseBufferMemory(queue, obj(), offset, size, mem.obj(), mem_offset) == VK_SUCCESS);
Mark Lobodzinski942b1722015-05-11 17:21:15 -0500664}
665
Courtney Goeltzenleuchter95487bc2015-04-14 18:48:46 -0600666void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800667{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600668 DERIVED_OBJECT_TYPE_INIT(vkCreateBufferView, dev, VK_OBJECT_TYPE_BUFFER_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600669 alloc_memory();
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800670}
671
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600672void Image::init(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800673{
674 init_no_mem(dev, info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600675 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800676}
677
Tony Barbour4c97d7a2015-04-22 15:10:33 -0600678void Image::init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags &reqs)
679{
680 init_no_mem(dev, info);
681 alloc_memory(reqs);
682}
683
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600684void Image::init_no_mem(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800685{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600686 DERIVED_OBJECT_TYPE_INIT(vkCreateImage, dev, VK_OBJECT_TYPE_IMAGE, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800687 init_info(dev, info);
688}
689
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600690void Image::init(const Device &dev, const VkPeerImageOpenInfo &info, const VkImageCreateInfo &original_info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800691{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600692 VkImage img;
Tony Barbourd1c35722015-04-16 15:59:00 -0600693 VkDeviceMemory mem;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600694 dev_ = &dev;
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600695 EXPECT(vkOpenPeerImage(dev.obj(), &info, &img, &mem) == VK_SUCCESS);
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600696 Object::init(img, VK_OBJECT_TYPE_IMAGE);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800697
698 init_info(dev, original_info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600699 alloc_memory(std::vector<VkDeviceMemory>(1, mem));
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800700}
701
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600702void Image::init_info(const Device &dev, const VkImageCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800703{
704 create_info_ = info;
705
706 for (std::vector<Device::Format>::const_iterator it = dev.formats().begin(); it != dev.formats().end(); it++) {
707 if (memcmp(&it->format, &create_info_.format, sizeof(it->format)) == 0 && it->tiling == create_info_.tiling) {
708 format_features_ = it->features;
709 break;
710 }
711 }
712}
713
Mark Lobodzinski23065352015-05-29 09:32:35 -0500714void Image::bind_memory(const Device &dev, const VkImageMemoryBindInfo &info,
Tony Barbourd1c35722015-04-16 15:59:00 -0600715 const GpuMemory &mem, VkDeviceSize mem_offset)
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800716{
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500717 VkQueue queue = dev.graphics_queues()[0]->obj();
Mark Lobodzinski23065352015-05-29 09:32:35 -0500718 EXPECT(vkQueueBindSparseImageMemory(queue, obj(), &info, mem.obj(), mem_offset) == VK_SUCCESS);
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800719}
720
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600721VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800722{
Tony Barbourd1c35722015-04-16 15:59:00 -0600723 const VkSubresourceInfoType type = VK_SUBRESOURCE_INFO_TYPE_LAYOUT;
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600724 VkSubresourceLayout data;
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800725 size_t size = sizeof(data);
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600726 if (!EXPECT(vkGetImageSubresourceInfo(dev_->obj(), obj(), &subres, type, &size, &data) == VK_SUCCESS && size == sizeof(data)))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800727 memset(&data, 0, sizeof(data));
728
729 return data;
730}
731
732bool Image::transparent() const
733{
Tony Barbourd1c35722015-04-16 15:59:00 -0600734 return (create_info_.tiling == VK_IMAGE_TILING_LINEAR &&
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800735 create_info_.samples == 1 &&
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600736 !(create_info_.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
737 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)));
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800738}
739
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600740void ImageView::init(const Device &dev, const VkImageViewCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800741{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600742 DERIVED_OBJECT_TYPE_INIT(vkCreateImageView, dev, VK_OBJECT_TYPE_IMAGE_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600743 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800744}
745
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600746void ColorAttachmentView::init(const Device &dev, const VkColorAttachmentViewCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800747{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600748 DERIVED_OBJECT_TYPE_INIT(vkCreateColorAttachmentView, dev, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600749 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800750}
751
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600752void DepthStencilView::init(const Device &dev, const VkDepthStencilViewCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800753{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600754 DERIVED_OBJECT_TYPE_INIT(vkCreateDepthStencilView, dev, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600755 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800756}
757
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600758void Shader::init(const Device &dev, const VkShaderCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800759{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600760 DERIVED_OBJECT_TYPE_INIT(vkCreateShader, dev, VK_OBJECT_TYPE_SHADER, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800761}
762
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600763VkResult Shader::init_try(const Device &dev, const VkShaderCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800764{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600765 /*
766 * Note: Cannot use DERIVED_OBJECT_TYPE_INIT as we need the
767 * return code.
768 */
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600769 VkShader sh;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600770 dev_ = &dev;
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600771 VkResult err = vkCreateShader(dev.obj(), &info, &sh);
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600772 if (err == VK_SUCCESS)
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600773 Object::init(sh, VK_OBJECT_TYPE_SHADER);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800774
775 return err;
776}
777
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600778void Pipeline::init(const Device &dev, const VkGraphicsPipelineCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800779{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600780 DERIVED_OBJECT_TYPE_INIT(vkCreateGraphicsPipeline, dev, VK_OBJECT_TYPE_PIPELINE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600781 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800782}
783
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600784void Pipeline::init(
785 const Device &dev,
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600786 const VkGraphicsPipelineCreateInfo &info,
787 const VkPipeline basePipeline)
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600788{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600789 DERIVED_OBJECT_TYPE_INIT(vkCreateGraphicsPipelineDerivative, dev, VK_OBJECT_TYPE_PIPELINE, &info, basePipeline);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600790 alloc_memory();
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600791}
792
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600793void Pipeline::init(const Device &dev, const VkComputePipelineCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800794{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600795 DERIVED_OBJECT_TYPE_INIT(vkCreateComputePipeline, dev, VK_OBJECT_TYPE_PIPELINE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600796 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800797}
798
799void Pipeline::init(const Device&dev, size_t size, const void *data)
800{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600801 DERIVED_OBJECT_TYPE_INIT(vkLoadPipeline, dev, VK_OBJECT_TYPE_PIPELINE, size, data);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600802 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800803}
804
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600805void Pipeline::init(
806 const Device&dev,
807 size_t size,
808 const void *data,
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600809 const VkPipeline basePipeline)
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600810{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600811 DERIVED_OBJECT_TYPE_INIT(vkLoadPipelineDerivative, dev, VK_OBJECT_TYPE_PIPELINE, size, data, basePipeline);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600812 alloc_memory();
Courtney Goeltzenleuchter0d40f152015-03-25 15:37:49 -0600813}
814
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800815size_t Pipeline::store(size_t size, void *data)
816{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600817 if (!EXPECT(vkStorePipeline(dev_->obj(), obj(), &size, data) == VK_SUCCESS))
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800818 size = 0;
819
820 return size;
821}
822
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600823void Sampler::init(const Device &dev, const VkSamplerCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800824{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600825 DERIVED_OBJECT_TYPE_INIT(vkCreateSampler, dev, VK_OBJECT_TYPE_SAMPLER, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600826 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800827}
828
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600829void DescriptorSetLayout::init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800830{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600831 DERIVED_OBJECT_TYPE_INIT(vkCreateDescriptorSetLayout, dev, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600832 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800833}
834
Mark Lobodzinski0fadf5f2015-04-17 14:11:39 -0500835void PipelineLayout::init(const Device &dev, VkPipelineLayoutCreateInfo &info, const std::vector<const DescriptorSetLayout *> &layouts)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800836{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600837 const std::vector<VkDescriptorSetLayout> layout_objs = make_objects<VkDescriptorSetLayout>(layouts);
Mark Lobodzinski0fadf5f2015-04-17 14:11:39 -0500838 info.pSetLayouts = &layout_objs[0];
Chia-I Wu41126e52015-03-26 15:27:55 +0800839
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600840 DERIVED_OBJECT_TYPE_INIT(vkCreatePipelineLayout, dev, VK_OBJECT_TYPE_PIPELINE_LAYOUT, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600841 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800842}
843
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600844void DescriptorPool::init(const Device &dev, VkDescriptorPoolUsage usage,
845 uint32_t max_sets, const VkDescriptorPoolCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800846{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600847 DERIVED_OBJECT_TYPE_INIT(vkCreateDescriptorPool, dev, VK_OBJECT_TYPE_DESCRIPTOR_POOL, usage, max_sets, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600848 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800849}
850
Chia-I Wufae40bc2015-03-26 15:23:52 +0800851void DescriptorPool::reset()
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800852{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600853 EXPECT(vkResetDescriptorPool(dev_->obj(), obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800854}
855
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500856std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const std::vector<const DescriptorSetLayout *> &layouts)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800857{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600858 const std::vector<VkDescriptorSetLayout> layout_objs = make_objects<VkDescriptorSetLayout>(layouts);
Chia-I Wu11078b02015-01-04 16:27:24 +0800859
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600860 std::vector<VkDescriptorSet> set_objs;
Chia-I Wu11078b02015-01-04 16:27:24 +0800861 set_objs.resize(layout_objs.size());
862
863 uint32_t set_count;
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600864 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 -0600865 if (err == VK_SUCCESS)
Chia-I Wu11078b02015-01-04 16:27:24 +0800866 EXPECT(set_count == set_objs.size());
867 set_objs.resize(set_count);
868
869 std::vector<DescriptorSet *> sets;
870 sets.reserve(set_count);
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600871 for (std::vector<VkDescriptorSet>::const_iterator it = set_objs.begin(); it != set_objs.end(); it++) {
Chia-I Wu11078b02015-01-04 16:27:24 +0800872 // do descriptor sets need memories bound?
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600873 DescriptorSet *descriptorSet = new DescriptorSet(dev, *it);
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500874 sets.push_back(descriptorSet);
Chia-I Wu11078b02015-01-04 16:27:24 +0800875 }
Chia-I Wu11078b02015-01-04 16:27:24 +0800876 return sets;
877}
878
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500879std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout, uint32_t count)
Chia-I Wu11078b02015-01-04 16:27:24 +0800880{
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500881 return alloc_sets(dev, usage, std::vector<const DescriptorSetLayout *>(count, &layout));
Chia-I Wu11078b02015-01-04 16:27:24 +0800882}
883
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500884DescriptorSet *DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout)
Chia-I Wu11078b02015-01-04 16:27:24 +0800885{
Mark Lobodzinski40f7f402015-04-16 11:44:05 -0500886 std::vector<DescriptorSet *> set = alloc_sets(dev, usage, layout, 1);
Chia-I Wu11078b02015-01-04 16:27:24 +0800887 return (set.empty()) ? NULL : set[0];
888}
889
Chia-I Wu985ba162015-03-26 13:14:16 +0800890void DescriptorPool::clear_sets(const std::vector<DescriptorSet *> &sets)
Chia-I Wu11078b02015-01-04 16:27:24 +0800891{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600892 const std::vector<VkDescriptorSet> set_objs = make_objects<VkDescriptorSet>(sets);
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600893 vkClearDescriptorSets(dev_->obj(), obj(), set_objs.size(), &set_objs[0]);
Chia-I Wu11078b02015-01-04 16:27:24 +0800894}
895
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600896void DynamicVpStateObject::init(const Device &dev, const VkDynamicVpStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800897{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600898 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicViewportState, dev, VK_OBJECT_TYPE_DYNAMIC_VP_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600899 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800900}
901
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600902void DynamicRsStateObject::init(const Device &dev, const VkDynamicRsStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800903{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600904 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicRasterState, dev, VK_OBJECT_TYPE_DYNAMIC_RS_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600905 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800906}
907
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600908void DynamicCbStateObject::init(const Device &dev, const VkDynamicCbStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800909{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600910 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicColorBlendState, dev, VK_OBJECT_TYPE_DYNAMIC_CB_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600911 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800912}
913
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600914void DynamicDsStateObject::init(const Device &dev, const VkDynamicDsStateCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800915{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600916 DERIVED_OBJECT_TYPE_INIT(vkCreateDynamicDepthStencilState, dev, VK_OBJECT_TYPE_DYNAMIC_DS_STATE, &info);
Courtney Goeltzenleuchter30a39452015-04-22 10:02:41 -0600917 alloc_memory();
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800918}
919
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600920void CmdBuffer::init(const Device &dev, const VkCmdBufferCreateInfo &info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800921{
Courtney Goeltzenleuchter992fb4f2015-04-19 19:07:33 -0600922 DERIVED_OBJECT_TYPE_INIT(vkCreateCommandBuffer, dev, VK_OBJECT_TYPE_COMMAND_BUFFER, &info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800923}
924
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600925void CmdBuffer::begin(const VkCmdBufferBeginInfo *info)
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800926{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600927 EXPECT(vkBeginCommandBuffer(obj(), info) == VK_SUCCESS);
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700928}
929
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600930void CmdBuffer::begin(VkRenderPass renderpass_obj, VkFramebuffer framebuffer_obj)
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700931{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600932 VkCmdBufferBeginInfo info = {};
933 VkCmdBufferGraphicsBeginInfo graphics_cmd_buf_info = {};
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600934 graphics_cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
Tony Barbourbdf0a312015-04-01 17:10:07 -0600935 graphics_cmd_buf_info.pNext = NULL;
Courtney Goeltzenleuchter69894b72015-04-03 15:25:24 -0600936 graphics_cmd_buf_info.renderPassContinue.renderPass = renderpass_obj;
937 graphics_cmd_buf_info.renderPassContinue.framebuffer = framebuffer_obj;
Tony Barbourbdf0a312015-04-01 17:10:07 -0600938
Tony Barbourd1c35722015-04-16 15:59:00 -0600939 info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600940 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
941 info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700942 info.pNext = &graphics_cmd_buf_info;
943
944 begin(&info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800945}
946
947void CmdBuffer::begin()
948{
Courtney Goeltzenleuchterfb4efc62015-04-10 08:34:15 -0600949 VkCmdBufferBeginInfo info = {};
Tony Barbourd1c35722015-04-16 15:59:00 -0600950 info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600951 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
952 info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700953
954 begin(&info);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800955}
956
957void CmdBuffer::end()
958{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600959 EXPECT(vkEndCommandBuffer(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800960}
961
962void CmdBuffer::reset()
963{
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600964 EXPECT(vkResetCommandBuffer(obj()) == VK_SUCCESS);
Chia-I Wuf1e2e992014-12-27 14:12:52 +0800965}
966
Courtney Goeltzenleuchterd8e229c2015-04-08 15:36:08 -0600967}; // namespace vk_testing