Blender V5.3
gpu/shader_tool/metadata.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "metadata.hh"
10
12
13std::string ParsedResource::serialize() const
14{
15 std::string res_condition_lambda;
16
17 if (!res_condition.empty()) {
18 res_condition_lambda = ", [](blender::Span<CompilationConstant> constants) { ";
19 res_condition_lambda += res_condition;
20 res_condition_lambda += "}";
21 }
22
23 std::stringstream ss;
24 if (res_type == "legacy_info") {
25 ss << "ADDITIONAL_INFO(" << var_name << ")";
26 }
27 else if (res_type == "legacy_iface") {
28 ss << "VERTEX_OUT(" << var_type << "_t)";
29 }
30 else if (res_type == "resource_table") {
31 if (!res_condition.empty()) {
32 ss << ".additional_info_with_condition(\"" << var_type << "\"" << res_condition_lambda
33 << ")";
34 }
35 else {
36 ss << ".additional_info(\"" << var_type << "\")";
37 }
38 }
39 else if (res_type == "sampler") {
40 ss << ".sampler(" << res_slot;
41 ss << ", ImageType::" << var_type;
42 ss << ", \"" << var_name << "\"";
43 ss << ", Frequency::" << res_frequency;
44 ss << res_condition_lambda << ")";
45 }
46 else if (res_type == "image") {
47 ss << ".image(" << res_slot;
48 ss << ", blender::gpu::TextureFormat::" << res_format;
49 ss << ", Qualifier::" << res_qualifier;
50 ss << ", ImageReadWriteType::" << var_type;
51 ss << ", \"" << var_name << "\"";
52 ss << ", Frequency::" << res_frequency;
53 ss << res_condition_lambda << ")";
54 }
55 else if (res_type == "uniform") {
56 ss << ".uniform_buf(" << res_slot;
57 ss << ", \"" << var_type << "\"";
58 ss << ", \"" << var_name << var_array << "\"";
59 ss << ", Frequency::" << res_frequency;
60 ss << res_condition_lambda << ")";
61 }
62 else if (res_type == "storage") {
63 ss << ".storage_buf(" << res_slot;
64 ss << ", Qualifier::" << res_qualifier;
65 ss << ", \"" << var_type << "\"";
66 ss << ", \"" << var_name << var_array << "\"";
67 ss << ", Frequency::" << res_frequency;
68 ss << res_condition_lambda << ")";
69 }
70 else if (res_type == "acceleration_structure") {
71 ss << ".acceleration_structure(" << res_slot;
72 ss << ", \"" << var_name << "\"";
73 ss << ", Frequency::" << res_frequency;
74 ss << res_condition_lambda << ")";
75 }
76 else if (res_type == "shared") {
77 ss << "GROUP_SHARED(" << var_type << ", " << var_name << var_array << ")";
78 }
79 else if (res_type == "push_constant") {
80 if (!var_array.empty()) {
81 ss << "PUSH_CONSTANT_ARRAY(" << var_type << ", " << var_name << ", "
82 << var_array.substr(1, var_array.size() - 2) << ")";
83 }
84 else {
85 ss << ".push_constant(Type::" << var_type << "_t, \"" << var_name << "\", 0"
86 << res_condition_lambda << ")";
87 }
88 }
89 else if (res_type == "compilation_constant") {
90 /* Needs to be defined on the shader declaration. */
91 /* TODO(fclem): Add check that shader sets an existing compilation constant. */
92 // ss << "COMPILATION_CONSTANT(" << var_type << ", " << var_name << ", " << res_value << ")";
93 /* WORKAROUND: Avoid unused expression warning. */
94 ss << ".noop()\n";
95 }
96 else if (res_type == "specialization_constant") {
97 ss << "SPECIALIZATION_CONSTANT(" << var_type << ", " << var_name << ", " << res_value << ")";
98 }
99 return ss.str();
100}
101
102std::string ParsedAttribute::serialize() const
103{
104 std::stringstream ss;
105 if (interpolation_mode == "flat") {
106 ss << "FLAT(" << var_type << ", " << var_name << ")";
107 }
108 else if (interpolation_mode == "smooth") {
109 ss << "SMOOTH(" << var_type << ", " << var_name << ")";
110 }
111 else if (interpolation_mode == "no_perspective") {
112 ss << "NO_PERSPECTIVE(" << var_type << ", " << var_name << ")";
113 }
114 return ss.str();
115}
116
117std::string StageInterface::serialize() const
118{
119 std::stringstream ss;
120 ss << "GPU_SHADER_INTERFACE_INFO(" << name << "_t)\n";
121
122 for (const auto &res : *this) {
123 ss << res.serialize() << "\n";
124 }
125
126 ss << "GPU_SHADER_INTERFACE_END()\n";
127 return ss.str();
128}
129
130std::string ParsedFragOuput::serialize() const
131{
132 std::stringstream ss;
133 if (!dual_source.empty()) {
134 ss << "FRAGMENT_OUT_DUAL(" << slot << ", " << var_type << ", " << var_name << ", "
135 << "SRC_" << dual_source << ")";
136 }
137 else if (!raster_order_group.empty()) {
138 ss << "FRAGMENT_OUT_ROG(" << slot << ", " << var_type << ", " << var_name << ", "
139 << raster_order_group << ")";
140 }
141 else {
142 ss << "FRAGMENT_OUT(" << slot << ", " << var_type << ", " << var_name << ")";
143 }
144 return ss.str();
145}
146
147std::string ParsedFragInput::serialize() const
148{
149 std::stringstream ss;
150 ss << "SUBPASS_IN(" << slot << ", " << var_type << ", " << image_type << ", " << var_name << ", "
151 << raster_order_group << ")";
152 return ss.str();
153}
154
155std::string FragmentOutputs::serialize() const
156{
157 std::stringstream ss;
158 ss << "GPU_SHADER_CREATE_INFO(" << name << ")\n";
159
160 for (const auto &res : *this) {
161 ss << res.serialize() << "\n";
162 }
163
164 ss << "GPU_SHADER_CREATE_END()\n";
165 return ss.str();
166}
167
168std::string FragmentInputs::serialize() const
169{
170 std::stringstream ss;
171 ss << "GPU_SHADER_CREATE_INFO(" << name << ")\n";
172
173 for (const auto &res : *this) {
174 ss << res.serialize() << "\n";
175 }
176
177 ss << "GPU_SHADER_CREATE_END()\n";
178 return ss.str();
179}
180
181std::string ParsedVertInput::serialize() const
182{
183 std::string res_condition_lambda;
184
185 if (!res_condition.empty()) {
186 res_condition_lambda = ", [](blender::Span<CompilationConstant> constants) { ";
187 res_condition_lambda += res_condition;
188 res_condition_lambda += "}";
189 }
190
191 std::stringstream ss;
192 ss << ".vertex_in(" << slot << ", Type::" << var_type << "_t, \"" << var_name << "\""
193 << res_condition_lambda << ")";
194 return ss.str();
195}
196
197std::string VertexInputs::serialize() const
198{
199 std::stringstream ss;
200 ss << "GPU_SHADER_CREATE_INFO(" << name << ")\n";
201
202 for (const auto &res : *this) {
203 ss << res.serialize() << "\n";
204 }
205
206 ss << "GPU_SHADER_CREATE_END()\n";
207 return ss.str();
208}
209
210static std::string enum_to_string(metadata::Qualifier qualifier)
211{
212 switch (qualifier) {
214 return "in";
216 return "out";
218 return "inout";
219 }
220 return "";
221}
222
223static std::string enum_to_string(metadata::Type type_enum)
224{
225 switch (type_enum) {
227 return "float1";
229 return "float2";
231 return "float3";
233 return "float4";
235 return "float3x3";
237 return "float4x4";
239 return "int1";
241 return "int2";
243 return "int3";
245 return "int4";
247 return "bool1";
249 return "sampler1DArray";
251 return "sampler2DArray";
253 return "sampler2D";
255 return "sampler3D";
257 return "Closure";
259 return "KernelGlobals";
261 return "ShadingData";
262 }
263 return "";
264}
265
266std::string Source::serialize(const std::string &function_name) const
267{
268 std::stringstream ss;
269 ss << "static void " << function_name
270 << "(GPUSource &source, GPUFunctionDictionary *g_functions, GPUPrintFormatMap *g_formats) "
271 "{\n";
272 for (auto function : functions) {
273 ss << " {\n";
274 ss << " Vector<metadata::ArgumentFormat> args = {\n";
275 for (auto arg : function.arguments) {
276 ss << " "
277 << "metadata::ArgumentFormat{"
278 << "metadata::Qualifier::" << enum_to_string(arg.qualifier) << ", "
279 << "metadata::Type::" << enum_to_string(arg.type) << ""
280 << "},\n";
281 }
282 ss << " };\n";
283 ss << " source.add_function(\"" << function.name << "\", args, g_functions);\n";
284 ss << " }\n";
285 }
286 for (auto builtin : builtins) {
287 ss << " source.add_builtin(metadata::Builtin(" << std::to_string(builtin) << "LLU));\n";
288 }
289 for (auto dependency : dependencies) {
290 ss << " source.add_dependency(\"" << dependency << "\");\n";
291 }
292 for (auto var : shared_variables) {
293 ss << " source.add_shared_variable(Type::" << var.type << "_t, \"" << var.name << "\");\n";
294 }
295 for (auto format : printf_formats) {
296 ss << " source.add_printf_format(uint32_t(" << std::to_string(format.hash) << "), "
297 << format.format << ", g_formats);\n";
298 }
299 /* Avoid warnings. */
300 ss << " UNUSED_VARS(source, g_functions, g_formats);\n";
301 ss << "}\n";
302 return ss.str();
303}
304
305std::string Source::serialize_infos() const
306{
307 std::stringstream ss;
308 ss << "#pragma once\n";
309 ss << "\n";
310 for (auto dependency : create_infos_dependencies) {
311 ss << "#include \"" << dependency << "\"\n";
312 }
313
314 for (auto builtin : builtins) {
316 /* Do not serialize create infos for runtime generated files. */
317 return ss.str();
318 }
319 }
320
321 ss << "\n";
322 for (auto define : create_infos_defines) {
323 ss << define;
324 }
325 ss << "\n";
326 for (auto vert_inputs : vertex_inputs) {
327 ss << vert_inputs.serialize() << "\n";
328 }
329 ss << "\n";
330 for (auto frag_outputs : fragment_outputs) {
331 ss << frag_outputs.serialize() << "\n";
332 }
333 for (auto frag_inputs : fragment_inputs) {
334 ss << frag_inputs.serialize() << "\n";
335 }
336 ss << "\n";
337 for (auto iface : stage_interfaces) {
338 ss << iface.serialize() << "\n";
339 }
340 ss << "\n";
341 for (auto res_table : resource_tables) {
342 ss << "GPU_SHADER_CREATE_INFO(" << res_table.name << ")\n";
343
344 if (res_table.empty()) {
345 /* Add unused define to avoid warning about unused expression. */
346 ss << "DEFINE(\"EMPTY_CREATE_INFO\")\n";
347 }
348 for (const auto &res : res_table) {
349 ss << res.serialize() << "\n";
350 }
351 ss << "GPU_SHADER_CREATE_END()\n";
352 }
353 ss << "\n";
354 for (auto declaration : create_infos_declarations) {
355 ss << declaration << "\n";
356 }
357 return ss.str();
358}
359} // namespace blender::gpu::shader::metadata
static std::string enum_to_string(metadata::Qualifier qualifier)
std::vector< std::string > create_infos_defines
Definition metadata.hh:281
std::vector< ResourceTable > resource_tables
Definition metadata.hh:282
std::vector< FragmentOutputs > fragment_outputs
Definition metadata.hh:284
std::vector< StageInterface > stage_interfaces
Definition metadata.hh:283
std::string serialize(const std::string &function_name) const
std::vector< FragmentInputs > fragment_inputs
Definition metadata.hh:285
std::vector< FunctionFormat > functions
Definition metadata.hh:277
std::vector< std::string > dependencies
Definition metadata.hh:274
std::vector< PrintfFormat > printf_formats
Definition metadata.hh:276
std::vector< VertexInputs > vertex_inputs
Definition metadata.hh:286
std::vector< std::string > create_infos_declarations
Definition metadata.hh:279
std::vector< SharedVariable > shared_variables
Definition metadata.hh:275
std::vector< Builtin > builtins
Definition metadata.hh:272
std::vector< std::string > create_infos_dependencies
Definition metadata.hh:280