Blender V5.3
dependencies.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 "NOD_dependencies.hh"
10
11#include "DNA_ID.h"
12#include "DNA_node_types.h"
13#include "DNA_object_types.h"
14
15#include "BKE_anim_data.hh"
16#include "BKE_image.hh"
18#include "BKE_node_runtime.hh"
19
21
22namespace blender::nodes {
23
25{
26 if (!id) {
27 return;
28 }
29 this->ids.add(id->session_uid, id);
30}
31
33{
34 if (!id) {
35 return;
36 }
37 if (GS(id->name) == ID_OB) {
38 this->add_object(reinterpret_cast<Object *>(id));
39 }
40 else {
41 this->add_generic_id(id);
42 }
43}
44
46{
47 if (!object) {
48 return;
49 }
50 this->add_generic_id(&object->id);
51 ObjectDependencyInfo &deps = this->objects_info.lookup_or_add(object->id.session_uid,
52 object_deps);
53 deps.geometry |= object_deps.geometry;
54 deps.transform |= object_deps.transform;
55 deps.camera_parameters |= object_deps.camera_parameters;
56 deps.pose |= object_deps.pose;
57}
58
60{
61 for (ID *id : other.ids.values()) {
62 this->add_generic_id(id);
63 }
64 for (const auto &&item : other.objects_info.items()) {
65 ID *id = other.ids.lookup(item.key);
66 BLI_assert(GS(id->name) == ID_OB);
67 this->add_object(reinterpret_cast<Object *>(id), item.value);
68 }
72 this->time_dependent |= other.time_dependent;
73}
74
75static bool is_used_default_input(const bNodeSocket &socket, const NodeDefaultInputType type)
76{
77 if (!socket.is_input()) {
78 return false;
79 }
80 if (socket.is_logically_linked()) {
81 return false;
82 }
83 if (!socket.runtime->declaration) {
84 return false;
85 }
86 return socket.runtime->declaration->default_input_type == type;
87}
88
90{
91 if (socket.is_input()) {
92 if (socket.is_logically_linked()) {
93 /* The input value is unused. */
94 return;
95 }
96 }
97 switch (socket.type) {
98 case SOCK_OBJECT: {
100 deps.needs_own_transform |= true;
101 }
102 else if (Object *object = static_cast<bNodeSocketValueObject *>(socket.default_value)->value)
103 {
104 deps.add_object(object);
105 }
106 break;
107 }
108 case SOCK_COLLECTION: {
109 if (Collection *collection =
110 static_cast<bNodeSocketValueCollection *>(socket.default_value)->value)
111 {
112 deps.add_generic_id(reinterpret_cast<ID *>(collection));
113 }
114 break;
115 }
116 case SOCK_MATERIAL: {
117 if (Material *material =
118 static_cast<bNodeSocketValueMaterial *>(socket.default_value)->value)
119 {
120 deps.add_generic_id(reinterpret_cast<ID *>(material));
121 }
122 break;
123 }
124 case SOCK_TEXTURE: {
125 if (Tex *texture = static_cast<bNodeSocketValueTexture *>(socket.default_value)->value) {
126 deps.add_generic_id(reinterpret_cast<ID *>(texture));
127 }
128 break;
129 }
130 case SOCK_IMAGE: {
131 if (Image *image = static_cast<bNodeSocketValueImage *>(socket.default_value)->value) {
132 deps.add_generic_id(reinterpret_cast<ID *>(image));
133 }
134 break;
135 }
136 case SOCK_FONT: {
137 if (VFont *font = static_cast<bNodeSocketValueFont *>(socket.default_value)->value) {
138 deps.add_generic_id(reinterpret_cast<ID *>(font));
139 }
140 break;
141 }
142 case SOCK_SCENE: {
143 if (Scene *scene = static_cast<bNodeSocketValueScene *>(socket.default_value)->value) {
144 deps.add_generic_id(reinterpret_cast<ID *>(scene));
145 }
146 break;
147 }
148 case SOCK_TEXT_ID: {
149 if (Text *text = static_cast<bNodeSocketValueText *>(socket.default_value)->value) {
150 deps.add_generic_id(reinterpret_cast<ID *>(text));
151 }
152 break;
153 }
154 case SOCK_MASK: {
155 if (Mask *mask = static_cast<bNodeSocketValueMask *>(socket.default_value)->value) {
156 deps.add_generic_id(reinterpret_cast<ID *>(mask));
157 }
158 break;
159 }
160 case SOCK_SOUND: {
161 if (bSound *sound = static_cast<bNodeSocketValueSound *>(socket.default_value)->value) {
162 deps.add_generic_id(reinterpret_cast<ID *>(sound));
163 }
164 break;
165 }
166 case SOCK_INT:
167 case SOCK_FLOAT: {
169 deps.time_dependent = true;
170 }
171 break;
172 }
173 default:
174 break;
175 }
176}
177
179{
180 for (const bNode *node : tree.all_nodes()) {
181 if (node->is_muted()) {
182 continue;
183 }
184
185 /* Group nodes are handles separately. */
186 if (node->is_group()) {
187 continue;
188 }
189
190 if (node->id == nullptr) {
191 continue;
192 }
193
194 ID_Type id_type = GS(node->id->name);
195 if (id_type == ID_OB) {
196 deps.add_object(reinterpret_cast<Object *>(node->id));
197 }
198 else if (id_type == ID_IM) {
199 if (BKE_image_is_animated(reinterpret_cast<Image *>(node->id))) {
200 deps.time_dependent = true;
201 }
202 deps.add_generic_id(node->id);
203 }
204 else {
205 deps.add_generic_id(node->id);
206 }
207 }
208}
209
210static bool has_enabled_nodes_of_type(const bNodeTree &tree, const UString type_idname)
211{
212 for (const bNode *node : tree.nodes_by_type(type_idname)) {
213 if (!node->is_muted()) {
214 return true;
215 }
216 }
217 return false;
218}
219
221{
222 bool needs_own_transform = false;
223
224 needs_own_transform |= has_enabled_nodes_of_type(tree, "GeometryNodeSelfObject"_ustr);
225 needs_own_transform |= has_enabled_nodes_of_type(tree, "GeometryNodeDeformCurvesOnSurface"_ustr);
226
227 for (const bNode *node : tree.nodes_by_type("GeometryNodeCollectionInfo"_ustr)) {
228 if (node->is_muted()) {
229 continue;
230 }
232 node->storage);
233 needs_own_transform |= storage.transform_space == GEO_NODE_TRANSFORM_SPACE_RELATIVE;
234 }
235
236 for (const bNode *node : tree.nodes_by_type("GeometryNodeObjectInfo"_ustr)) {
237 if (node->is_muted()) {
238 continue;
239 }
240 const NodeGeometryObjectInfo &storage = *static_cast<const NodeGeometryObjectInfo *>(
241 node->storage);
242 needs_own_transform |= storage.transform_space == GEO_NODE_TRANSFORM_SPACE_RELATIVE;
243 }
244
245 deps.needs_own_transform |= needs_own_transform;
246}
247
248static bool needs_scene_render_params(const bNodeTree &ntree)
249{
250 for (const bNode *node : ntree.nodes_by_type("GeometryNodeCameraInfo"_ustr)) {
251 if (node->is_muted()) {
252 continue;
253 }
254 const bNodeSocket &projection_matrix_socket = *node->output_by_identifier(
255 "Projection Matrix"_ustr);
256 if (projection_matrix_socket.is_logically_linked()) {
257 return true;
258 }
259 }
260 return false;
261}
262
264 const bNodeTree &ntree,
265 EvalDependencies &deps,
266 FunctionRef<const EvalDependencies *(const bNodeTree &group)> get_group_deps)
267{
268 ntree.ensure_topology_cache();
269 for (const bNodeSocket *socket : ntree.all_sockets()) {
271 }
273 "GeometryNodeInputActiveCamera"_ustr);
276 has_enabled_nodes_of_type(ntree, "GeometryNodeSimulationInput"_ustr) ||
277 has_enabled_nodes_of_type(ntree, "GeometryNodeInputSceneTime"_ustr) ||
278 has_enabled_nodes_of_type(ntree, "CompositorNodeSceneTime"_ustr) ||
279 has_enabled_nodes_of_type(ntree, "CompositorNodeTime"_ustr) ||
280 has_enabled_nodes_of_type(ntree, "CompositorNodeTrackPos"_ustr) ||
281 has_enabled_nodes_of_type(ntree, "CompositorNodeStabilize"_ustr) ||
282 has_enabled_nodes_of_type(ntree, "CompositorNodePlaneTrackDeform"_ustr) ||
283 has_enabled_nodes_of_type(ntree, "CompositorNodeMovieDistortion"_ustr) ||
284 has_enabled_nodes_of_type(ntree, "CompositorNodeMovieClip"_ustr) ||
285 has_enabled_nodes_of_type(ntree, "CompositorNodeKeyingScreen"_ustr);
286
289
290 for (const bNode *node : ntree.group_nodes()) {
291 if (!node->id) {
292 continue;
293 }
294 const bNodeTree &group = *reinterpret_cast<const bNodeTree *>(node->id);
295 if (const EvalDependencies *group_deps = get_group_deps(group)) {
296 deps.merge(*group_deps);
297 }
298 }
299}
300
302{
303 EvalDependencies deps;
305 ntree, deps, [](const bNodeTree &group) { return group.runtime->eval_dependencies.get(); });
306 return deps;
307}
308
310 const bNodeTree &ntree, Map<const bNodeTree *, EvalDependencies> &deps_by_tree)
311{
312 if (deps_by_tree.contains(&ntree)) {
313 return;
314 }
315 EvalDependencies new_deps;
316 gather_geometry_nodes_eval_dependencies(ntree, new_deps, [&](const bNodeTree &group) {
318 return &deps_by_tree.lookup(&group);
319 });
320 deps_by_tree.add(&ntree, std::move(new_deps));
321}
322
329
330} // namespace blender::nodes
ID and Library types, which are fundamental for SDNA.
Object is a sort of wrapper for general info.
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
const Value & lookup(const Key &key) const
Definition BLI_map.hh:545
bool contains(const Key &key) const
Definition BLI_map.hh:353
const nodes::SocketDeclaration * declaration
std::unique_ptr< nodes::EvalDependencies > eval_dependencies
#define storage(slot, qualifiers)
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
static bool has_enabled_nodes_of_type(const bNodeTree &tree, const UString type_idname)
static void gather_geometry_nodes_eval_dependencies_recursive_impl(const bNodeTree &ntree, Map< const bNodeTree *, EvalDependencies > &deps_by_tree)
static bool is_used_default_input(const bNodeSocket &socket, const NodeDefaultInputType type)
static void add_own_transform_dependencies(const bNodeTree &tree, EvalDependencies &deps)
EvalDependencies gather_eval_dependencies_recursive(const bNodeTree &ntree)
static bool needs_scene_render_params(const bNodeTree &ntree)
EvalDependencies gather_eval_dependencies_with_cache(const bNodeTree &ntree)
static void gather_geometry_nodes_eval_dependencies(const bNodeTree &ntree, EvalDependencies &deps, FunctionRef< const EvalDependencies *(const bNodeTree &group)> get_group_deps)
static void add_eval_dependencies_from_node_data(const bNodeTree &tree, EvalDependencies &deps)
static void add_eval_dependencies_from_socket(const bNodeSocket &socket, EvalDependencies &deps)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool BKE_image_is_animated(Image *image)
bool BKE_animdata_id_is_animated(const ID *id)
Definition anim_data.cc:224
@ GEO_NODE_TRANSFORM_SPACE_RELATIVE
ID_Type GS(const char *name)
Definition DNA_ID.h:410
eNodeSocketDatatype type
bke::bNodeSocketRuntime * runtime
bke::bNodeTreeRuntime * runtime
void add_object(Object *object, const ObjectDependencyInfo &object_deps=all_object_deps)
void merge(const EvalDependencies &other)
Map< uint32_t, ObjectDependencyInfo > objects_info