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
|
#pragma once
#include "xe_device.hpp"
// std
#include <memory>
#include <unordered_map>
#include <vector>
namespace xe {
class XeDescriptorSetLayout {
public:
class Builder {
public:
Builder(XeDevice &xeDevice) : xeDevice{xeDevice} {}
Builder &addBinding(
uint32_t binding,
VkDescriptorType descriptorType,
VkShaderStageFlags stageFlags,
VkSampler *sampler);
std::unique_ptr<XeDescriptorSetLayout> build() const;
private:
XeDevice &xeDevice;
std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings{};
};
XeDescriptorSetLayout(
XeDevice &xeDevice, std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings);
~XeDescriptorSetLayout();
XeDescriptorSetLayout(const XeDescriptorSetLayout &) = delete;
XeDescriptorSetLayout &operator=(const XeDescriptorSetLayout &) = delete;
VkDescriptorSetLayout getDescriptorSetLayout() const { return descriptorSetLayout; }
private:
XeDevice &xeDevice;
VkDescriptorSetLayout descriptorSetLayout;
std::unordered_map<uint32_t, VkDescriptorSetLayoutBinding> bindings;
friend class XeDescriptorWriter;
};
class XeDescriptorPool {
public:
class Builder {
public:
Builder(XeDevice &xeDevice) : xeDevice{xeDevice} {}
Builder &addPoolSize(VkDescriptorType descriptorType, uint32_t count);
Builder &setPoolFlags(VkDescriptorPoolCreateFlags flags);
Builder &setMaxSets(uint32_t count);
std::unique_ptr<XeDescriptorPool> build() const;
private:
XeDevice &xeDevice;
std::vector<VkDescriptorPoolSize> poolSizes{};
uint32_t maxSets = 1000;
VkDescriptorPoolCreateFlags poolFlags = 0;
};
XeDescriptorPool(
XeDevice &xeDevice,
uint32_t maxSets,
VkDescriptorPoolCreateFlags poolFlags,
const std::vector<VkDescriptorPoolSize> &poolSizes);
~XeDescriptorPool();
XeDescriptorPool(const XeDescriptorPool &) = delete;
XeDescriptorPool &operator=(const XeDescriptorPool &) = delete;
bool allocateDescriptor(
const VkDescriptorSetLayout descriptorSetLayout, VkDescriptorSet &descriptor) const;
void freeDescriptors(std::vector<VkDescriptorSet> &descriptors) const;
void resetPool();
private:
XeDevice &xeDevice;
VkDescriptorPool descriptorPool;
friend class XeDescriptorWriter;
};
class XeDescriptorWriter {
public:
XeDescriptorWriter(XeDescriptorSetLayout &setLayout, XeDescriptorPool &pool);
XeDescriptorWriter &writeBuffer(uint32_t binding, VkDescriptorBufferInfo *bufferInfo);
XeDescriptorWriter &writeImage(uint32_t binding, VkDescriptorImageInfo *imageInfo);
bool build(VkDescriptorSet &set);
void overwrite(VkDescriptorSet &set);
private:
XeDescriptorSetLayout &setLayout;
XeDescriptorPool &pool;
std::vector<VkWriteDescriptorSet> writes;
};
}
|
