Blender V5.3
vk_push_constants.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10#include "vk_backend.hh"
11#include "vk_buffer.hh"
12#include "vk_context.hh"
13#include "vk_memory_layout.hh"
14#include "vk_shader.hh"
16#include "vk_storage_buffer.hh"
17#include "vk_uniform_buffer.hh"
18
19namespace blender::gpu {
20
21template<typename LayoutT>
24 const ShaderInput &shader_input,
25 uint32_t *r_offset)
26{
27 align<LayoutT>(push_constant.type, push_constant.array_size, r_offset);
28
30 layout.location = shader_input.location;
31 layout.type = push_constant.type;
32 layout.array_size = push_constant.array_size;
33 layout.offset = *r_offset;
34 layout.inner_row_padding = LayoutT::inner_row_padding(push_constant.type);
35
36 reserve<LayoutT>(push_constant.type, push_constant.array_size, r_offset);
37 return layout;
38}
39
40template<typename LayoutT>
42{
43 uint32_t offset = 0;
44 for (const shader::ShaderCreateInfo::PushConst &push_constant : push_constants) {
45 align<LayoutT>(push_constant.type, push_constant.array_size, &offset);
46 reserve<LayoutT>(push_constant.type, push_constant.array_size, &offset);
47 }
48
49 align_end_of_struct<LayoutT>(&offset);
50 return offset;
51}
52
54 const shader::ShaderCreateInfo &info, const VKDevice &device)
55{
56 if (info.push_constants_.is_empty()) {
57 return StorageType::NONE;
58 }
59
60 uint32_t max_push_constants_size =
61 device.physical_device_properties_get().limits.maxPushConstantsSize;
63 return size <= max_push_constants_size ? STORAGE_TYPE_DEFAULT : STORAGE_TYPE_FALLBACK;
64}
65
66template<typename LayoutT>
68 const VKShaderInterface &interface,
70 uint32_t *r_offset)
71{
73 const ShaderInput *shader_input = interface.uniform_get(push_constant.name.c_str());
74 r_struct.append(init_constant<LayoutT>(push_constant, *shader_input, r_offset));
75 }
76 align_end_of_struct<Std140>(r_offset);
77}
78
80 const VKShaderInterface &interface,
81 const StorageType storage_type,
82 const VKDescriptorSet::Location location)
83{
84 BLI_assert(push_constants.is_empty());
85 storage_type_ = storage_type;
86
87 size_in_bytes_ = 0;
88 if (storage_type == StorageType::BUFFER) {
89 descriptor_set_location_ = location;
90 init_struct<Std140>(info, interface, push_constants, &size_in_bytes_);
91 }
92 else {
93 init_struct<Std430>(info, interface, push_constants, &size_in_bytes_);
94 }
95}
96
98{
99 for (const PushConstant &push_constant : push_constants) {
100 if (push_constant.location == location) {
101 return &push_constant;
102 }
103 }
104 return nullptr;
105}
106
108{
109 std::ostream &stream = std::cout;
110 stream << "VKPushConstants::Layout::debug_print()\n";
111 for (const PushConstant &push_constant : push_constants) {
112 stream << " - location:" << push_constant.location;
113 stream << ", offset:" << push_constant.offset;
114 stream << ", array_size:" << push_constant.array_size;
115 stream << "\n";
116 }
117}
118
120VKPushConstants::VKPushConstants(const Layout *layout) : layout_(layout)
121{
122 data_ = MEM_new_uninitialized(layout->size_in_bytes(), __func__);
123 if (G.debug & G_DEBUG_GPU) {
124 memset(data_, 0xFD, layout->size_in_bytes());
125 }
126}
127
128VKPushConstants::VKPushConstants(VKPushConstants &&other) : layout_(other.layout_)
129{
130 data_ = other.data_;
131 other.data_ = nullptr;
132}
133
135{
136 if (data_ != nullptr) {
137 MEM_delete_void(data_);
138 data_ = nullptr;
139 }
140}
141
143{
144 layout_ = other.layout_;
145
146 data_ = other.data_;
147 other.data_ = nullptr;
148
149 return *this;
150}
151
153{
154 BLI_assert(layout_->storage_type_get() == StorageType::BUFFER);
155 BLI_assert(data_ != nullptr);
156
158
159 context.push_constants_pool.append(
160 Span<uint8_t>(static_cast<const uint8_t *>(data_), layout_->size_in_bytes()));
161 return result;
162}
163
164} // namespace blender::gpu
const ShaderInput * uniform_get(const StringRefNull name) const
const VkPhysicalDeviceProperties & physical_device_properties_get() const
Definition vk_device.hh:294
VKBufferWithOffset update_uniform_buffer(VKContext &context)
VKPushConstants & operator=(VKPushConstants &&other)
#define push_constant
void init_struct(const shader::ShaderCreateInfo &info, const VKShaderInterface &interface, Vector< VKPushConstants::Layout::PushConstant > &r_struct, uint32_t *r_offset)
uint32_t struct_size(Span< shader::ShaderCreateInfo::PushConst > push_constants)
static VKPushConstants::Layout::PushConstant init_constant(const shader::ShaderCreateInfo::PushConst &push_constant, const ShaderInput &shader_input, uint32_t *r_offset)
static void align(const shader::Type &type, const int32_t array_size, uint32_t *r_offset)
void * MEM_new_uninitialized(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void MEM_delete_void(void *vmemh)
Global G
Definition blender.cc:57
unsigned int uint32_t
Definition BKE_text.h:81
unsigned char uint8_t
Definition BKE_text.h:79
signed int int32_t
Definition BKE_text.h:78
static constexpr StorageType STORAGE_TYPE_DEFAULT
static constexpr StorageType STORAGE_TYPE_FALLBACK
static StorageType determine_storage_type(const shader::ShaderCreateInfo &info, const VKDevice &device)
const PushConstant * find(int32_t location) const
void init(const shader::ShaderCreateInfo &info, const VKShaderInterface &interface, StorageType storage_type, VKDescriptorSet::Location location)
Describe inputs & outputs, stage interfaces, resources and sources of a shader. If all data is correc...