-
Notifications
You must be signed in to change notification settings - Fork 0
/
Buffer.cpp
153 lines (139 loc) · 6.37 KB
/
Buffer.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include "Buffer.h"
#include "Vkx.h"
#include <vulkan/vulkan.hpp>
namespace Vkx
{
//! @param device Logical device associated with the buffer
//! @param size Nominal size of the buffer
//! @param usage Usage flags
//! @param sharingMode Sharing mode
//! @param memoryProperties Memory properties
//! @param sharingMode Sharing mode flag (default: eExclusive)
//!
//! @warning A std::runtime_error is thrown if the buffer cannot be created and allocated
//! @todo "... you're not supposed to actually call vkAllocateMemory for every individual buffer. ... The right way to
//! allocate memory for a large number of objects at the same time is to create a custom allocator that splits up a
//! single allocation among many different objects by using the offset parameters that we've seen in many functions."
Buffer::Buffer(std::shared_ptr<Device> device,
size_t size,
vk::BufferUsageFlags usage,
vk::MemoryPropertyFlags memoryProperties,
vk::SharingMode sharingMode /*= vk::SharingMode::eExclusive*/)
: device_(device)
{
buffer_ = device_->createBufferUnique(vk::BufferCreateInfo({}, size, usage, sharingMode));
vk::MemoryRequirements requirements = device_->getBufferMemoryRequirements(*buffer_);
uint32_t memoryType = Vkx::findAppropriateMemoryType(device_->physical(),
requirements.memoryTypeBits,
memoryProperties);
allocation_ = device_->allocateMemoryUnique(vk::MemoryAllocateInfo(requirements.size, memoryType));
device_->bindBufferMemory(*buffer_, *allocation_, 0);
}
//! @param src Move source
Buffer::Buffer(Buffer && src)
: device_(std::move(src.device_))
, allocation_(std::move(src.allocation_))
, buffer_(std::move(src.buffer_))
{
}
//! @param rhs Move source
Buffer & Buffer::operator =(Buffer && rhs)
{
if (this != &rhs)
{
device_ = std::move(rhs.device_);
allocation_ = std::move(rhs.allocation_);
buffer_ = std::move(rhs.buffer_);
}
return *this;
}
//! @param device Logical device associated with the buffer
//! @param size Nominal size of the buffer
//! @param usage Usage flags
//! @param src Data to be copied into the buffer, or nullptr if nothing to copy (default: nullptr)
//! @param sharingMode Sharing mode flag (default: eExclusive)
HostBuffer::HostBuffer(std::shared_ptr<Device> device,
size_t size,
vk::BufferUsageFlags usage,
void const * src /*= nullptr*/,
vk::SharingMode sharingMode /*= vk::SharingMode::eExclusive*/)
: Buffer(device,
size,
usage,
vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
sharingMode)
{
if (src)
set(0, src, size);
}
//! @param offset Where in the buffer to put the copied data
//! @param src Data to be copied into the buffer
//! @param size Size of the data to copy
void HostBuffer::set(size_t offset, void const * src, size_t size)
{
char * data = (char *)device_->mapMemory(allocation(), 0, size, vk::MemoryMapFlags());
memcpy(data + offset, src, size);
device_->unmapMemory(allocation());
}
//! @param device Logical device associated with the buffer
//! @param size Nominal size of the buffer
//! @param usage Usage flags
//! @param sharingMode Sharing mode flag (default: eExclusive)
LocalBuffer::LocalBuffer(std::shared_ptr<Device> device,
size_t size,
vk::BufferUsageFlags usage,
vk::SharingMode sharingMode /*= vk::SharingMode::eExclusive*/)
: Buffer(device,
size,
usage | vk::BufferUsageFlagBits::eTransferDst,
vk::MemoryPropertyFlagBits::eDeviceLocal,
sharingMode)
{
}
//! @param device Logical device associated with the buffer
//! @param commandPool Command pool used to initialize the buffer
//! @param queue Queue used to initialize the buffer
//! @param size Nominal size of the buffer
//! @param usage Usage flags
//! @param src Data to be copied into the buffer
//! @param sharingMode Sharing mode flag (default: eExclusive)
LocalBuffer::LocalBuffer(std::shared_ptr<Device> device,
vk::CommandPool const & commandPool,
vk::Queue const & queue,
size_t size,
vk::BufferUsageFlags usage,
void const * src,
vk::SharingMode sharingMode /*= vk::SharingMode::eExclusive*/)
: Buffer(device,
size,
usage | vk::BufferUsageFlagBits::eTransferDst,
vk::MemoryPropertyFlagBits::eDeviceLocal,
sharingMode)
{
set(commandPool, queue, src, size);
}
//! @param commandPool Command pool used to copy data into the buffer
//! @param queue Queue used to copy data into the buffer
//! @param src Data to be copied into the buffer
//! @param size Size of the data to copy
void LocalBuffer::set(vk::CommandPool const & commandPool,
vk::Queue const & queue,
void const * src,
size_t size)
{
HostBuffer staging(device_,
size,
vk::BufferUsageFlagBits::eTransferSrc,
src);
copySynched(commandPool, queue, staging, size);
}
void LocalBuffer::copySynched(vk::CommandPool const & commandPool,
vk::Queue const & queue,
Buffer & src,
size_t size)
{
executeOnceSynched(device_, commandPool, queue, [&src, this, size] (vk::CommandBuffer commands) {
commands.copyBuffer(src, *this->buffer_, vk::BufferCopy(0, 0, size));
});
}
} // namespace Vkx