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
|
#pragma once
#include "data_buffer.hpp"
#include "cpu_buffer.hpp"
#include "gpu_buffer.hpp"
#include "std/utility.hpp"
namespace dp
{
/// generic implementation of data buffer
template <typename TBuffer>
class DataBufferImpl : public DataBufferBase
{
public:
template<typename... Args> DataBufferImpl(Args&&... params)
: m_buffer(make_unique_dp<TBuffer>(forward<Args>(params)...))
{
}
uint32_t GetCapacity() const override
{
return m_buffer->GetCapacity();
}
uint32_t GetCurrentSize() const override
{
return m_buffer->GetCurrentSize();
}
uint32_t GetAvailableSize() const override
{
return m_buffer->GetAvailableSize();
}
uint8_t GetElementSize() const override
{
return m_buffer->GetElementSize();
}
void Seek(uint32_t elementNumber) override
{
m_buffer->Seek(elementNumber);
}
protected:
drape_ptr<TBuffer> m_buffer;
};
/// CPU implementation of data buffer
class CpuBufferImpl : public DataBufferImpl<CPUBuffer>
{
public:
template<typename... Args> CpuBufferImpl(Args&&... params)
: DataBufferImpl(forward<Args>(params)...)
{}
void const * Data() const override
{
return m_buffer->Data();
}
void UploadData(void const * data, uint32_t elementCount) override
{
m_buffer->UploadData(data, elementCount);
uint32_t const newOffset = m_buffer->GetCurrentSize();
m_buffer->Seek(newOffset);
}
void UpdateData(void * destPtr, void const * srcPtr, uint32_t elementOffset, uint32_t elementCount) override
{
ASSERT(false, ("Data updating is unavailable for CPU buffer"));
}
void Bind() override
{
ASSERT(false, ("Binding is unavailable for CPU buffer"));
}
void * Map() override
{
ASSERT(false, ("Mapping is unavailable for CPU buffer"));
return nullptr;
}
void Unmap() override
{
ASSERT(false, ("Unmapping is unavailable for CPU buffer"));
}
};
/// GPU implementation of data buffer
class GpuBufferImpl : public DataBufferImpl<GPUBuffer>
{
public:
template<typename... Args> GpuBufferImpl(Args&&... params)
: DataBufferImpl(forward<Args>(params)...)
{}
void const * Data() const override
{
ASSERT(false, ("Retrieving of raw data is unavailable for GPU buffer"));
return nullptr;
}
void UploadData(void const * data, uint32_t elementCount) override
{
m_buffer->UploadData(data, elementCount);
}
void UpdateData(void * destPtr, void const * srcPtr, uint32_t elementOffset, uint32_t elementCount) override
{
m_buffer->UpdateData(destPtr, srcPtr, elementOffset, elementCount);
}
void Bind() override
{
m_buffer->Bind();
}
void * Map() override
{
return m_buffer->Map();
}
void Unmap() override
{
return m_buffer->Unmap();
}
};
} // namespace dp
|
