Blender V5.3
scene_compositor_effects_operation.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include <memory>
6
7#include "BLI_listbase.hh"
8#include "BLI_math_euler.hh"
9
10#include "DNA_scene_types.h"
11
12#include "RNA_access.hh"
13#include "RNA_prototypes.hh"
14
15#include "BKE_compositor.hh"
18#include "BKE_node.hh"
19#include "BKE_node_runtime.hh"
20
23#include "COM_scheduler.hh"
24#include "COM_utilities.hh"
25
26namespace blender::compositor {
27
34
36{
37 if (context.render_context()) {
39 }
41}
42
44 PointerRNA &effect_inputs_ptr,
45 const bNodeTreeInterfaceSocket &input_socket)
46{
47 PointerRNA input_ptr = RNA_pointer_get(&effect_inputs_ptr, input_socket.identifier);
49 context.create_result(get_node_interface_socket_result_type(input_socket)));
50 result->allocate_single_value();
51 switch (input_socket.socket_typeinfo()->type) {
52 case SOCK_FLOAT: {
53 const float value = RNA_float_get(&input_ptr, "value");
54 result->set_single_value(value);
55 break;
56 }
57 case SOCK_VECTOR: {
58 switch (static_cast<bNodeSocketValueVector *>(input_socket.socket_data)->dimensions) {
59 case 2: {
60 float2 value;
61 RNA_float_get_array(&input_ptr, "value", value);
62 result->set_single_value(value);
63 break;
64 }
65 case 3: {
66 float3 value;
67 RNA_float_get_array(&input_ptr, "value", value);
68 result->set_single_value(value);
69 break;
70 }
71 case 4: {
72 float4 value;
73 RNA_float_get_array(&input_ptr, "value", value);
74 result->set_single_value(value);
75 break;
76 }
77 default:
79 }
80 break;
81 }
82 case SOCK_RGBA: {
83 ColorGeometry4f value;
84 RNA_float_get_array(&input_ptr, "value", value);
85 result->set_single_value(value);
86 break;
87 }
88 case SOCK_BOOLEAN: {
89 const bool value = RNA_boolean_get(&input_ptr, "value");
90 result->set_single_value(value);
91 break;
92 }
93 case SOCK_INT: {
94 const int value = RNA_int_get(&input_ptr, "value");
95 result->set_single_value(value);
96 break;
97 }
98 case SOCK_ROTATION: {
99 float3 value_euler;
100 RNA_float_get_array(&input_ptr, "value", value_euler);
101 math::Quaternion value_rotation = math::to_quaternion(math::EulerXYZ(value_euler));
102 result->set_single_value(value_rotation);
103 break;
104 }
105 case SOCK_MENU: {
106 const nodes::MenuValue value = nodes::MenuValue(RNA_enum_get(&input_ptr, "value"));
107 result->set_single_value(value);
108 break;
109 }
110 case SOCK_STRING: {
111 const std::string value = RNA_string_get(&input_ptr, "value");
112 result->set_single_value(value);
113 break;
114 }
115 case SOCK_INT_VECTOR: {
116 switch (static_cast<bNodeSocketValueIntVector *>(input_socket.socket_data)->dimensions) {
117 case 2: {
118 int2 value;
119 RNA_int_get_array(&input_ptr, "value", value);
120 result->set_single_value(value);
121 break;
122 }
123 case 3: {
124 int3 value;
125 RNA_int_get_array(&input_ptr, "value", value);
126 result->set_single_value(value);
127 break;
128 }
129 default:
131 }
132 break;
133 }
134 case SOCK_OBJECT: {
135 Object *value = RNA_pointer_get(&input_ptr, "value").data_as<Object>();
136 result->set_single_value(value);
137 break;
138 }
139 case SOCK_FONT: {
140 VFont *value = RNA_pointer_get(&input_ptr, "value").data_as<VFont>();
141 result->set_single_value(value);
142 break;
143 }
144 case SOCK_IMAGE:
145 case SOCK_COLLECTION:
146 case SOCK_TEXTURE:
147 case SOCK_MATERIAL:
148 case SOCK_SCENE:
149 case SOCK_TEXT_ID:
150 case SOCK_MASK:
151 case SOCK_SOUND:
152 case SOCK_GEOMETRY:
153 case SOCK_MATRIX:
154 case SOCK_BUNDLE:
155 case SOCK_CLOSURE:
156 case SOCK_SHADER:
157 case SOCK_CUSTOM:
158 break;
159 }
160
161 return result;
162}
163
165{
166 const Scene &scene = this->context().get_scene();
167 const bke::DataBlockComputeContext &scene_compute_context =
168 this->context().compute_context_cache().for_data_block(nullptr, scene.id);
169
170 const bool needs_viewer_output = flag_is_set(this->context().needed_side_effect_output_types(),
172 const bool has_viewer_output = needs_viewer_output && this->context().viewer_compute_context();
173
174 std::unique_ptr<NodeGroupOperation> last_operation;
175 const bke::compositor::ExecutionMode execution_mode = get_execution_mode(this->context());
176 for (const SceneCompositorEffect &effect : scene.compositor_effects) {
177 if (this->context().is_canceled()) {
178 break;
179 }
180
181 if (!bke::compositor::is_effect_enabled(effect, execution_mode)) {
182 continue;
183 }
184
185 const bke::SceneCompositorEffectComputeContext &effect_compute_context =
186 this->context().compute_context_cache().for_scene_compositor_effect(&scene_compute_context,
187 effect);
188
189 const bNodeTree &node_group = *effect.node_group;
190 NodeGroupOperation *effect_operation = new NodeGroupOperation(
191 this->context(), node_group, effect_compute_context);
192
193 /* We need the output of the effect if:
194 * - We are doing a final render.
195 * - We need a viewer output but do not have a viewer, in which case, the output of the last
196 * effect will be double as the viewer output.
197 * - We need a viewer output and have a viewer, in which case, the output is needed until the
198 * active effect, since it is the one that have the viewer. Note that we break if this is
199 * false, so effects after the active one are not evaluated. */
200 const bool is_active_effect = flag_is_set(effect.flags, SceneCompositorEffectFlags::IsActive);
201 const bool is_effect_output_needed = this->context().render_context() ||
202 (needs_viewer_output && !has_viewer_output) ||
203 (needs_viewer_output && has_viewer_output &&
204 !is_active_effect);
205
206 /* Set the reference count for the outputs, only the first color output is actually needed,
207 * while the rest are ignored. */
208 bool effect_has_output = false;
209 node_group.ensure_interface_cache();
210 for (const bNodeTreeInterfaceSocket *output_socket : node_group.interface_outputs()) {
211 const bool is_first_output = output_socket == node_group.interface_outputs().first();
212 Result &output_result = effect_operation->get_result(output_socket->identifier);
213 const bool is_color = output_result.type() == ResultType::Color;
214 const bool is_needed = is_effect_output_needed && is_first_output && is_color;
215 output_result.set_reference_count(is_needed ? 1 : 0);
216 effect_has_output = effect_has_output || is_needed;
217 }
218
220 const_cast<ID *>(&scene.id),
221 RNA_SceneCompositorEffect,
222 const_cast<SceneCompositorEffect *>(&effect));
223 PointerRNA effect_properties_ptr = RNA_pointer_get(&effect_ptr, "properties");
224 PointerRNA effect_inputs_ptr = RNA_pointer_get(&effect_properties_ptr, "inputs");
225
226 /* Map the inputs to the operation. */
227 Vector<std::unique_ptr<Result>> temporary_inputs;
228 for (const bNodeTreeInterfaceSocket *input_socket : node_group.interface_inputs()) {
229 if (input_socket != node_group.interface_inputs().first()) {
230 Result *input_result = get_effect_input(this->context(), effect_inputs_ptr, *input_socket);
231 effect_operation->map_input_to_result(input_socket->identifier, input_result);
232 temporary_inputs.append(std::unique_ptr<Result>(input_result));
233 continue;
234 }
235
236 /* If a last operation exists, link its output. */
237 if (last_operation) {
238 /* Last operation had no output, so link an invalid result. */
239 if (last_operation->node_group().interface_outputs().is_empty()) {
240 Result *invalid_result = new Result(this->context().create_result(ResultType::Color));
241 invalid_result->allocate_invalid();
242 effect_operation->map_input_to_result(input_socket->identifier, invalid_result);
243 temporary_inputs.append(std::unique_ptr<Result>(invalid_result));
244 continue;
245 }
246 const bNodeTreeInterfaceSocket *last_operation_output =
247 last_operation->node_group().interface_outputs().first();
248 Result &output_result = last_operation->get_result(last_operation_output->identifier);
249 effect_operation->map_input_to_result(input_socket->identifier, &output_result);
250 continue;
251 }
252
253 /* Otherwise, we link the input of the operation. */
254 Result &base_input = this->get_input();
255 Result *operation_input = new Result(this->context().create_result(base_input.type()));
256 operation_input->share_data(base_input);
257 effect_operation->map_input_to_result(input_socket->identifier, operation_input);
258 temporary_inputs.append(std::unique_ptr<Result>(operation_input));
259 }
260
261 effect_operation->evaluate();
262
263 last_operation.reset(effect_operation);
264
265 /* If the effect does not have an output, then we needn't compute later effects. */
266 if (!effect_has_output) {
267 break;
268 }
269 }
270
271 /* If no last operation exist or if it has no outputs, then there is nothing to do. The last
272 * operation can be nullptr because execution may have been canceled before any operation was
273 * evaluated. */
274 if (!last_operation || last_operation->node_group().interface_outputs().is_empty()) {
276 return;
277 }
278
279 /* Execution was canceled, so there is nothing to do, but we make sure to free any results. */
280 if (this->context().is_canceled()) {
281 last_operation->free_results();
283 return;
284 }
285
286 /* The output is not actually needed, so default allocate the operation output. */
287 Result &output_result = last_operation->get_result(
288 last_operation->node_group().interface_outputs().first()->identifier);
289 if (!output_result.should_compute()) {
291 return;
292 }
293
294 /* Share the first output of the last operation with the operation result. */
295 this->get_result().share_data(output_result);
296 output_result.release();
297 has_output_ = true;
298}
299
300} // namespace blender::compositor
#define BLI_assert_unreachable()
const DataBlockComputeContext & for_data_block(const ComputeContext *parent, const uint32_t orig_session_uid, const ID *id=nullptr)
const SceneCompositorEffectComputeContext & for_scene_compositor_effect(const ComputeContext *parent, const SceneCompositorEffect &effect)
virtual const Scene & get_scene() const =0
bke::ComputeContextCache & compute_context_cache() const
virtual const ComputeContext * viewer_compute_context() const =0
virtual RenderContext * render_context() const
NodeGroupOperation(Context &context, const bNodeTree &node_group, const ComputeContext &compute_context)
Result & get_result(StringRef identifier)
Definition operation.cc:40
Context & context() const
Definition operation.cc:57
void map_input_to_result(StringRef identifier, Result *result)
Definition operation.cc:45
void share_data(const Result &source)
Definition result.cc:996
bool should_compute() const
Definition result.cc:1124
static ResultType type(gpu::TextureFormat format)
Definition result.cc:337
Result(Context &context)
Definition result.cc:39
void set_reference_count(int count)
Definition result.cc:1079
void declare_input_descriptor(InputDescriptor descriptor)
bool is_effect_enabled(const SceneCompositorEffect &effect, ExecutionMode mode)
ResultType get_node_interface_socket_result_type(const bNodeTreeInterfaceSocket &socket)
Definition utilities.cc:123
static bke::compositor::ExecutionMode get_execution_mode(const Context &context)
static Result * get_effect_input(Context &context, PointerRNA &effect_inputs_ptr, const bNodeTreeInterfaceSocket &input_socket)
QuaternionBase< float > Quaternion
QuaternionBase< T > to_quaternion(const AxisAngleBase< T, AngleT > &axis_angle)
EulerXYZBase< float > EulerXYZ
int RNA_enum_get(PointerRNA *ptr, const char *name)
int RNA_int_get(PointerRNA *ptr, const char *name)
void RNA_int_get_array(PointerRNA *ptr, const char *name, int *values)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
std::string RNA_string_get(PointerRNA *ptr, const char *name)
float RNA_float_get(PointerRNA *ptr, const char *name)
void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values)
T * data_as() const
Definition RNA_types.hh:139
SceneCompositorEffectFlags flags
ListBaseT< SceneCompositorEffect > compositor_effects