Blender V5.3
pass.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "scene/pass.h"
6
7#include "util/log.h"
8#include "util/time.h"
9
11
12const char *pass_type_as_string(const PassType type)
13{
14 const int type_int = static_cast<int>(type);
15
16 const NodeEnum *type_enum = Pass::get_type_enum();
17
18 if (!type_enum->exists(type_int)) {
19 LOG_DFATAL << "Unhandled pass type " << static_cast<int>(type) << ", not supposed to happen.";
20 return "UNKNOWN";
21 }
22
23 return (*type_enum)[type_int].c_str();
24}
25
27{
28 switch (mode) {
29 case PassMode::NOISY:
30 return "NOISY";
32 return "DENOISED";
33 }
34
35 LOG_DFATAL << "Unhandled pass mode " << static_cast<int>(mode) << ", should never happen.";
36 return "UNKNOWN";
37}
38
39std::ostream &operator<<(std::ostream &os, PassMode mode)
40{
41 os << pass_mode_as_string(mode);
42 return os;
43}
44
46{
47 static NodeEnum pass_type_enum;
48
49 if (pass_type_enum.empty()) {
50
51 /* Light Passes. */
52 pass_type_enum.insert("combined", PASS_COMBINED);
53 pass_type_enum.insert("emission", PASS_EMISSION);
54 pass_type_enum.insert("background", PASS_BACKGROUND);
55 pass_type_enum.insert("ao", PASS_AO);
56 pass_type_enum.insert("diffuse", PASS_DIFFUSE);
57 pass_type_enum.insert("diffuse_direct", PASS_DIFFUSE_DIRECT);
58 pass_type_enum.insert("diffuse_indirect", PASS_DIFFUSE_INDIRECT);
59 pass_type_enum.insert("glossy", PASS_GLOSSY);
60 pass_type_enum.insert("glossy_direct", PASS_GLOSSY_DIRECT);
61 pass_type_enum.insert("glossy_indirect", PASS_GLOSSY_INDIRECT);
62 pass_type_enum.insert("transmission", PASS_TRANSMISSION);
63 pass_type_enum.insert("transmission_direct", PASS_TRANSMISSION_DIRECT);
64 pass_type_enum.insert("transmission_indirect", PASS_TRANSMISSION_INDIRECT);
65 pass_type_enum.insert("volume", PASS_VOLUME);
66 pass_type_enum.insert("volume_direct", PASS_VOLUME_DIRECT);
67 pass_type_enum.insert("volume_indirect", PASS_VOLUME_INDIRECT);
68 pass_type_enum.insert("volume_scatter", PASS_VOLUME_SCATTER);
69 pass_type_enum.insert("volume_transmit", PASS_VOLUME_TRANSMIT);
70
71 /* Data passes. */
72 pass_type_enum.insert("depth", PASS_DEPTH);
73 pass_type_enum.insert("position", PASS_POSITION);
74 pass_type_enum.insert("normal", PASS_NORMAL);
75 pass_type_enum.insert("roughness", PASS_ROUGHNESS);
76 pass_type_enum.insert("uv", PASS_UV);
77 pass_type_enum.insert("object_id", PASS_OBJECT_ID);
78 pass_type_enum.insert("material_id", PASS_MATERIAL_ID);
79 pass_type_enum.insert("motion", PASS_MOTION);
80 pass_type_enum.insert("motion_weight", PASS_MOTION_WEIGHT);
81 pass_type_enum.insert("cryptomatte", PASS_CRYPTOMATTE);
82 pass_type_enum.insert("aov_color", PASS_AOV_COLOR);
83 pass_type_enum.insert("aov_value", PASS_AOV_VALUE);
84 pass_type_enum.insert("adaptive_aux_buffer", PASS_ADAPTIVE_AUX_BUFFER);
85 pass_type_enum.insert("sample_count", PASS_SAMPLE_COUNT);
86 pass_type_enum.insert("diffuse_color", PASS_DIFFUSE_COLOR);
87 pass_type_enum.insert("glossy_color", PASS_GLOSSY_COLOR);
88 pass_type_enum.insert("transmission_color", PASS_TRANSMISSION_COLOR);
89 pass_type_enum.insert("mist", PASS_MIST);
90 pass_type_enum.insert("denoising_albedo", PASS_DENOISING_ALBEDO);
91 pass_type_enum.insert("denoising_specular_albedo", PASS_DENOISING_SPECULAR_ALBEDO);
92 pass_type_enum.insert("denoising_normal", PASS_DENOISING_NORMAL);
93 pass_type_enum.insert("denoising_roughness", PASS_DENOISING_ROUGHNESS);
94 pass_type_enum.insert("denoising_depth", PASS_DENOISING_DEPTH);
95 pass_type_enum.insert("denoising_backward_motion", PASS_DENOISING_BACKWARD_MOTION);
96 pass_type_enum.insert("denoising_specular_motion", PASS_DENOISING_SPECULAR_MOTION);
97 pass_type_enum.insert("denoising_previous", PASS_DENOISING_PREVIOUS);
98 pass_type_enum.insert("volume_majorant", PASS_VOLUME_MAJORANT);
99 pass_type_enum.insert("volume_majorant_sample_count", PASS_VOLUME_MAJORANT_SAMPLE_COUNT);
100 pass_type_enum.insert("render_time", PASS_RENDER_TIME);
101
102 pass_type_enum.insert("shadow_catcher", PASS_SHADOW_CATCHER);
103 pass_type_enum.insert("shadow_catcher_sample_count", PASS_SHADOW_CATCHER_SAMPLE_COUNT);
104 pass_type_enum.insert("shadow_catcher_matte", PASS_SHADOW_CATCHER_MATTE);
105
106 pass_type_enum.insert("bake_primitive", PASS_BAKE_PRIMITIVE);
107 pass_type_enum.insert("bake_seed", PASS_BAKE_SEED);
108 pass_type_enum.insert("bake_differential", PASS_BAKE_DIFFERENTIAL);
109
110#ifdef WITH_CYCLES_DEBUG
111 pass_type_enum.insert("guiding_color", PASS_GUIDING_COLOR);
112 pass_type_enum.insert("guiding_probability", PASS_GUIDING_PROBABILITY);
113 pass_type_enum.insert("guiding_avg_roughness", PASS_GUIDING_AVG_ROUGHNESS);
114#endif
115 }
116
117 return &pass_type_enum;
118}
119
121{
122 static NodeEnum pass_mode_enum;
123
124 if (pass_mode_enum.empty()) {
125 pass_mode_enum.insert("noisy", static_cast<int>(PassMode::NOISY));
126 pass_mode_enum.insert("denoised", static_cast<int>(PassMode::DENOISED));
127 }
128
129 return &pass_mode_enum;
130}
131
133{
134 NodeType *type = NodeType::add("pass", create);
135
136 const NodeEnum *pass_type_enum = get_type_enum();
137 const NodeEnum *pass_mode_enum = get_mode_enum();
138
139 SOCKET_ENUM(type, "Type", *pass_type_enum, PASS_COMBINED);
140 SOCKET_ENUM(mode, "Mode", *pass_mode_enum, static_cast<int>(PassMode::DENOISED));
141 SOCKET_STRING(name, "Name", ustring());
142 SOCKET_BOOLEAN(include_albedo, "Include Albedo", false);
143 SOCKET_STRING(lightgroup, "Light Group", ustring());
144
145 return type;
146}
147
148Pass::Pass() : Node(get_node_type()), is_auto_(false) {}
149
151{
152 return get_info(type, mode, include_albedo, !lightgroup.empty());
153}
154
156{
157 return get_info().is_written;
158}
159
161 const PassMode mode,
162 const bool include_albedo,
163 const bool is_lightgroup)
164{
165 PassInfo pass_info;
166
167 pass_info.use_filter = true;
168 pass_info.use_exposure = false;
169 pass_info.divide_type = PASS_NONE;
170 pass_info.use_compositing = false;
171 pass_info.use_denoising_albedo = true;
172
173 switch (type) {
174 case PASS_NONE:
175 pass_info.num_components = 0;
176 break;
177 case PASS_COMBINED:
178 pass_info.num_components = is_lightgroup ? 3 : 4;
179 pass_info.use_exposure = true;
180 pass_info.support_denoise = !is_lightgroup;
181 break;
182 case PASS_DEPTH:
183 pass_info.num_components = 1;
184 pass_info.use_filter = false;
185 break;
186 case PASS_MIST:
187 pass_info.num_components = 1;
188 break;
189 case PASS_POSITION:
190 pass_info.num_components = 3;
191 pass_info.use_filter = false;
192 break;
193 case PASS_NORMAL:
194 pass_info.num_components = 3;
195 break;
196 case PASS_ROUGHNESS:
197 pass_info.num_components = 1;
198 break;
199 case PASS_UV:
200 pass_info.num_components = 3;
201 break;
202 case PASS_MOTION:
203 pass_info.num_components = 4;
205 break;
207 pass_info.num_components = 1;
208 break;
209 case PASS_OBJECT_ID:
210 case PASS_MATERIAL_ID:
211 pass_info.num_components = 1;
212 pass_info.use_filter = false;
213 break;
214
215 case PASS_EMISSION:
216 case PASS_BACKGROUND:
217 pass_info.num_components = 3;
218 pass_info.use_exposure = true;
219 break;
220 case PASS_AO:
221 pass_info.num_components = 3;
222 break;
223
227 pass_info.num_components = 3;
228 break;
229 case PASS_DIFFUSE:
230 pass_info.num_components = 3;
231 pass_info.use_exposure = true;
234 pass_info.divide_type = (!include_albedo) ? PASS_DIFFUSE_COLOR : PASS_NONE;
235 pass_info.use_compositing = true;
236 pass_info.is_written = false;
237 break;
240 pass_info.num_components = 3;
241 pass_info.use_exposure = true;
242 pass_info.divide_type = (!include_albedo) ? PASS_DIFFUSE_COLOR : PASS_NONE;
243 pass_info.use_compositing = true;
244 break;
245 case PASS_GLOSSY:
246 pass_info.num_components = 3;
247 pass_info.use_exposure = true;
250 pass_info.divide_type = (!include_albedo) ? PASS_GLOSSY_COLOR : PASS_NONE;
251 pass_info.use_compositing = true;
252 pass_info.is_written = false;
253 break;
256 pass_info.num_components = 3;
257 pass_info.use_exposure = true;
258 pass_info.divide_type = (!include_albedo) ? PASS_GLOSSY_COLOR : PASS_NONE;
259 pass_info.use_compositing = true;
260 break;
262 pass_info.num_components = 3;
263 pass_info.use_exposure = true;
266 pass_info.divide_type = (!include_albedo) ? PASS_TRANSMISSION_COLOR : PASS_NONE;
267 pass_info.use_compositing = true;
268 pass_info.is_written = false;
269 break;
272 pass_info.num_components = 3;
273 pass_info.use_exposure = true;
274 pass_info.divide_type = (!include_albedo) ? PASS_TRANSMISSION_COLOR : PASS_NONE;
275 pass_info.use_compositing = true;
276 break;
277 case PASS_VOLUME:
278 pass_info.num_components = 3;
279 pass_info.use_exposure = true;
282 pass_info.use_compositing = true;
283 pass_info.is_written = false;
284 break;
287 pass_info.num_components = 3;
288 pass_info.use_exposure = true;
289 break;
292 /* Noisy buffer needs higher precision for accumulating the contribution, denoised buffer is
293 * used directly and thus can have lower resolution. */
294 pass_info.num_components = (mode == PassMode::NOISY) ? 3 : 1;
295 pass_info.use_exposure = true;
296 pass_info.use_filter = false;
297 pass_info.support_denoise = true;
298 break;
300 pass_info.num_components = 1;
301 pass_info.use_filter = false;
303 break;
305 pass_info.num_components = 1;
306 pass_info.use_filter = false;
307 break;
308
309 case PASS_CRYPTOMATTE:
310 pass_info.num_components = 4;
311 break;
312
318 pass_info.num_components = 3;
319 break;
322 pass_info.num_components = 1;
323 break;
325 pass_info.num_components = 3;
326 pass_info.use_exposure = true;
327 break;
328
330 pass_info.num_components = 3;
331 pass_info.use_exposure = false;
332 pass_info.use_compositing = true;
333 pass_info.use_denoising_albedo = false;
334 pass_info.support_denoise = true;
335 break;
337 pass_info.num_components = 1;
338 break;
340 pass_info.num_components = 4;
341 pass_info.use_exposure = true;
342 pass_info.support_denoise = true;
343 /* Without shadow catcher approximation compositing is not needed.
344 * Since we don't know here whether approximation is used or not, leave the decision up to
345 * the caller which will know that. */
346 break;
347
349 pass_info.num_components = 4;
350 break;
352 pass_info.num_components = 1;
353 pass_info.use_exposure = false;
354 break;
355 case PASS_RENDER_TIME:
356 pass_info.num_components = 1;
357 pass_info.use_exposure = false;
358 pass_info.use_filter = false;
359 pass_info.scale = 1000.0f / float(time_fast_frequency());
360 break;
361
362 case PASS_AOV_COLOR:
363 pass_info.num_components = 4;
364 break;
365 case PASS_AOV_VALUE:
366 pass_info.num_components = 1;
367 break;
368
370 pass_info.num_components = 3;
371 pass_info.use_exposure = false;
372 pass_info.use_filter = false;
373 break;
374 case PASS_BAKE_SEED:
375 pass_info.num_components = 1;
376 pass_info.use_exposure = false;
377 pass_info.use_filter = false;
378 break;
380 pass_info.num_components = 4;
381 pass_info.use_exposure = false;
382 pass_info.use_filter = false;
383 break;
384
386 pass_info.num_components = 3;
387 break;
389 pass_info.num_components = 1;
390 break;
392 pass_info.num_components = 1;
393 break;
394
395 default:
396 LOG_DFATAL << "Unexpected pass type is used " << type;
397 pass_info.num_components = 0;
398 break;
399 }
400
401 return pass_info;
402}
403
405{
406 for (const Pass *pass : passes) {
407 if (pass->get_type() != type) {
408 continue;
409 }
410
411 return true;
412 }
413
414 return false;
415}
416
417const Pass *Pass::find(const unique_ptr_vector<Pass> &passes, const string &name)
418{
419 for (const Pass *pass : passes) {
420 if (pass->get_name() == name) {
421 return pass;
422 }
423 }
424
425 return nullptr;
426}
427
430 PassMode mode,
431 const ustring &lightgroup)
432{
433 for (const Pass *pass : passes) {
434 if (pass->get_type() != type || pass->get_mode() != mode ||
435 pass->get_lightgroup() != lightgroup)
436 {
437 continue;
438 }
439 return pass;
440 }
441
442 return nullptr;
443}
444
445int Pass::get_offset(const unique_ptr_vector<Pass> &passes, const Pass *pass)
446{
447 int pass_offset = 0;
448
449 for (const Pass *current_pass : passes) {
450 /* Note that pass name is allowed to be empty. This is why we check for type and mode. */
451 if (current_pass->get_type() == pass->get_type() &&
452 current_pass->get_mode() == pass->get_mode() &&
453 current_pass->get_name() == pass->get_name())
454 {
455 if (current_pass->is_written()) {
456 return pass_offset;
457 }
458 return PASS_UNUSED;
459 }
460 if (current_pass->is_written()) {
461 pass_offset += current_pass->get_info().num_components;
462 }
463 }
464
465 return PASS_UNUSED;
466}
467
468std::ostream &operator<<(std::ostream &os, const Pass &pass)
469{
470 os << "type: " << pass_type_as_string(pass.get_type());
471 os << ", name: \"" << pass.get_name() << "\"";
472 os << ", mode: " << pass.get_mode();
473 os << ", is_written: " << string_from_bool(pass.is_written());
474
475 return os;
476}
477
478bool is_volume_guiding_pass(const PassType pass_type)
479{
480 return (pass_type == PASS_VOLUME_SCATTER) || (pass_type == PASS_VOLUME_TRANSMIT);
481}
482
Definition pass.h:50
static const Pass * find(const unique_ptr_vector< Pass > &passes, const string &name)
Definition pass.cpp:417
PassInfo get_info() const
Definition pass.cpp:150
static int get_offset(const unique_ptr_vector< Pass > &passes, const Pass *pass)
Definition pass.cpp:445
static bool contains(const unique_ptr_vector< Pass > &passes, PassType type)
Definition pass.cpp:404
static const NodeEnum * get_type_enum()
Definition pass.cpp:45
NODE_DECLARE Pass()
Definition pass.cpp:148
bool is_written() const
Definition pass.cpp:155
static const NodeEnum * get_mode_enum()
Definition pass.cpp:120
bool is_auto_
Definition pass.h:72
#define PASS_UNUSED
#define CCL_NAMESPACE_END
std::ostream & operator<<(std::ostream &os, DeviceKernel kernel)
PassType
@ PASS_SHADOW_CATCHER_SAMPLE_COUNT
@ PASS_EMISSION
@ PASS_POSITION
@ PASS_BACKGROUND
@ PASS_TRANSMISSION_DIRECT
@ PASS_VOLUME_DIRECT
@ PASS_UV
@ PASS_TRANSMISSION_COLOR
@ PASS_SHADOW_CATCHER_MATTE
@ PASS_GUIDING_COLOR
@ PASS_DEPTH
@ PASS_MIST
@ PASS_VOLUME_SCATTER
@ PASS_TRANSMISSION_INDIRECT
@ PASS_BAKE_SEED
@ PASS_SHADOW_CATCHER
@ PASS_VOLUME_MAJORANT
@ PASS_DENOISING_NORMAL
@ PASS_ROUGHNESS
@ PASS_DIFFUSE_DIRECT
@ PASS_MOTION
@ PASS_MATERIAL_ID
@ PASS_VOLUME_MAJORANT_SAMPLE_COUNT
@ PASS_AO
@ PASS_COMBINED
@ PASS_DIFFUSE
@ PASS_DENOISING_BACKWARD_MOTION
@ PASS_DIFFUSE_INDIRECT
@ PASS_RENDER_TIME
@ PASS_GUIDING_PROBABILITY
@ PASS_ADAPTIVE_AUX_BUFFER
@ PASS_GLOSSY
@ PASS_OBJECT_ID
@ PASS_DENOISING_SPECULAR_MOTION
@ PASS_DENOISING_ROUGHNESS
@ PASS_AOV_COLOR
@ PASS_NONE
@ PASS_DENOISING_SPECULAR_ALBEDO
@ PASS_VOLUME_INDIRECT
@ PASS_TRANSMISSION
@ PASS_NORMAL
@ PASS_CRYPTOMATTE
@ PASS_DIFFUSE_COLOR
@ PASS_SAMPLE_COUNT
@ PASS_GLOSSY_DIRECT
@ PASS_MOTION_WEIGHT
@ PASS_DENOISING_ALBEDO
@ PASS_VOLUME
@ PASS_AOV_VALUE
@ PASS_GUIDING_AVG_ROUGHNESS
@ PASS_GLOSSY_COLOR
@ PASS_DENOISING_PREVIOUS
@ PASS_GLOSSY_INDIRECT
@ PASS_BAKE_DIFFERENTIAL
@ PASS_VOLUME_TRANSMIT
@ PASS_DENOISING_DEPTH
@ PASS_BAKE_PRIMITIVE
#define LOG_DFATAL
Definition log.h:100
#define NODE_DEFINE(structname)
Definition node_type.h:157
#define SOCKET_BOOLEAN(name, ui_name, default_value,...)
Definition node_type.h:211
#define SOCKET_STRING(name, ui_name, default_value,...)
Definition node_type.h:231
#define SOCKET_ENUM(name, ui_name, values, default_value,...)
Definition node_type.h:235
const char * pass_mode_as_string(PassMode mode)
Definition pass.cpp:26
CCL_NAMESPACE_BEGIN const char * pass_type_as_string(const PassType type)
Definition pass.cpp:12
bool is_volume_guiding_pass(const PassType pass_type)
Definition pass.cpp:478
PassMode
Definition pass.h:20
@ DENOISED
Definition pass.h:22
@ NOISY
Definition pass.h:21
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
string string_from_bool(bool var)
Definition string.cpp:185
void insert(const char *x, const int y)
Definition node_enum.h:21
bool empty() const
Definition node_enum.h:17
bool exists(ustring x) const
Definition node_enum.h:29
static NodeType * add(const char *name, CreateFunc create, Type type=NONE, const NodeType *base=nullptr)
const NodeType * type
Definition graph/node.h:179
ustring name
Definition graph/node.h:178
Node(const NodeType *type, ustring name=ustring())
PassType direct_type
Definition pass.h:34
bool use_compositing
Definition pass.h:39
bool use_denoising_albedo
Definition pass.h:44
int num_components
Definition pass.h:28
float scale
Definition pass.h:32
bool support_denoise
Definition pass.h:47
bool use_filter
Definition pass.h:29
PassType divide_type
Definition pass.h:33
bool use_exposure
Definition pass.h:30
PassType indirect_type
Definition pass.h:35
bool is_written
Definition pass.h:31
uint64_t time_fast_frequency()
Definition time.cpp:121