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
|
//
//
#include "UniformAligner.h"
namespace graphics {
namespace util {
size_t alignSize(size_t size, size_t align) {
if (align == 0) {
return size;
}
auto remainder = size % align;
if (remainder == 0) {
return size;
}
return size + align - remainder;
}
UniformAligner::UniformAligner() = default;
UniformAligner::UniformAligner(uint8_t* buffer, size_t buffer_size, size_t dataSize, size_t headerSize,
size_t element_alignment)
: _requiredAlignment(element_alignment), _buffer(buffer), _buffer_size(buffer_size), _dataSize(dataSize),
_headerSize(headerSize)
{
_buffer_offset = alignSize(_headerSize, _requiredAlignment); // Set the initial offset to the first data element
}
void* UniformAligner::addElement()
{
Assertion(_buffer_offset + _dataSize <= _buffer_size,
"Not enough space in the buffer for adding another element! "
"Check the number of elements the buffer was allocated with!");
auto el_offset = _buffer_offset;
_buffer_offset += alignSize(_dataSize, _requiredAlignment);
++_numElements;
return reinterpret_cast<void*>(_buffer + el_offset);
}
void* UniformAligner::getElement(size_t index) {
size_t offset = alignSize(_headerSize, _requiredAlignment) + alignSize(_dataSize, _requiredAlignment) * index;
Assertion(offset < _buffer_size, "Invalid index specified!");
return reinterpret_cast<void*>(_buffer + offset);
}
size_t UniformAligner::getOffset(size_t index) {
size_t offset = alignSize(_headerSize, _requiredAlignment) + alignSize(_dataSize, _requiredAlignment) * index;
Assertion(offset < _buffer_size, "Invalid index specified!");
return offset;
}
void* UniformAligner::nextElement(void* currentEl) {
auto current = reinterpret_cast<uint8_t*>(currentEl);
current += alignSize(_dataSize, _requiredAlignment);
return reinterpret_cast<void*>(current);
}
size_t UniformAligner::getNumElements() {
return _numElements;
}
size_t UniformAligner::getSize() { return _buffer_size; }
void* UniformAligner::getData() { return _buffer; }
size_t UniformAligner::getCurrentOffset() { return getOffset(_numElements - 1); }
size_t UniformAligner::getBufferSize(size_t num_elements, size_t alignment, size_t dataSize, size_t headerSize)
{
auto alignedHeaderSize = alignSize(headerSize, alignment);
auto alignedElementSize = alignSize(dataSize, alignment);
return alignedHeaderSize + num_elements * alignedElementSize;
}
}
}
|
