Blender V5.3
node.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2005 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <fmt/format.h>
10
11#include "CLG_log.h"
12
13#include "MEM_guardedalloc.h"
14
15#include <algorithm>
16#include <cstddef>
17#include <cstdlib>
18#include <cstring>
19#include <optional>
20
21/* Allow using deprecated functionality for .blend file I/O. */
22#define DNA_DEPRECATED_ALLOW
23
26#include "DNA_light_types.h"
27#include "DNA_linestyle_types.h"
28#include "DNA_mask_types.h"
29#include "DNA_material_types.h"
30#include "DNA_node_types.h"
31#include "DNA_scene_types.h"
32#include "DNA_sound_types.h"
33#include "DNA_text_types.h"
34#include "DNA_texture_types.h"
35#include "DNA_userdef_types.h"
36#include "DNA_vfont_types.h"
37#include "DNA_world_types.h"
38
39#include "BLI_color_types.hh"
40#include "BLI_ghash.hh"
41#include "BLI_listbase.hh"
42#include "BLI_map.hh"
43#include "BLI_math_rotation.hh"
45#include "BLI_math_vector.hh"
46#include "BLI_math_vector_c.hh"
47#include "BLI_rand.hh"
48#include "BLI_set.hh"
49#include "BLI_stack.hh"
50#include "BLI_string.hh"
51#include "BLI_string_utf8.hh"
52#include "BLI_string_utils.hh"
53#include "BLI_time.hh"
54#include "BLI_utildefines.hh"
55#include "BLI_vector_set.hh"
56#include "BLT_translation.hh"
57
58#include "IMB_imbuf.hh"
59
60#include "BKE_anim_data.hh"
61#include "BKE_animsys.hh"
62#include "BKE_asset.hh"
63#include "BKE_bpath.hh"
64#include "BKE_colorband.hh"
65#include "BKE_colortools.hh"
66#include "BKE_context.hh"
67#include "BKE_global.hh"
68#include "BKE_idprop.hh"
69#include "BKE_idtype.hh"
70#include "BKE_image_format.hh"
71#include "BKE_lib_id.hh"
72#include "BKE_lib_query.hh"
73#include "BKE_main.hh"
74#include "BKE_node.hh"
75#include "BKE_node_enum.hh"
77#include "BKE_node_runtime.hh"
81#include "BKE_preview_image.hh"
85
86#include "RNA_access.hh"
87#include "RNA_define.hh"
88#include "RNA_enum_types.hh"
89#include "RNA_prototypes.hh"
90
91#include "NOD_common.hh"
92#include "NOD_composite.hh"
93#include "NOD_dependencies.hh"
94#include "NOD_geo_bake.hh"
95#include "NOD_geo_bundle.hh"
97#include "NOD_geo_closure.hh"
100#include "NOD_geo_menu_switch.hh"
102#include "NOD_geo_repeat.hh"
103#include "NOD_geo_simulation.hh"
107#include "NOD_menu_value.hh"
109#include "NOD_register.hh"
110#include "NOD_shader.h"
111#include "NOD_socket.hh"
113#include "NOD_texture.h"
114
115#include "DEG_depsgraph.hh"
116#include "DEG_depsgraph_build.hh"
117
118#include "BLO_read_write.hh"
119
120namespace blender {
121
122using nodes::NodeDeclaration;
123using nodes::SocketDeclaration;
124
125static CLG_LogRef LOG = {"node"};
126
127namespace bke {
128
129/* Forward declaration. */
130static void write_node_socket_default_value(BlendWriter *writer, const bNodeSocket *sock);
131
132/* Fallback types for undefined tree, nodes, sockets. */
136
137static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo);
138static void node_socket_set_typeinfo(bNodeTree *ntree,
139 bNodeSocket *sock,
140 bNodeSocketType *typeinfo);
141static void node_socket_copy(bNodeSocket *sock_dst, const bNodeSocket *sock_src, const int flag);
142static void free_localized_node_groups(bNodeTree *ntree);
143static void node_socket_free(bNodeSocket *sock, const bool do_id_user);
144
145static void ntree_init_data(ID *id)
146{
147 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
148 ntree->tree_interface.init_data();
149 ntree->runtime = MEM_new<bNodeTreeRuntime>(__func__);
151 ntree_set_typeinfo(ntree, nullptr);
152}
153
154static void ntree_copy_data(Main * /*bmain*/,
155 std::optional<Library *> /*owner_library*/,
156 ID *id_dst,
157 const ID *id_src,
158 const int flag)
159{
160 bNodeTree *ntree_dst = reinterpret_cast<bNodeTree *>(id_dst);
161 const bNodeTree *ntree_src = reinterpret_cast<const bNodeTree *>(id_src);
162
163 /* We never handle user-count here for owned data. */
164 const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
165
166 ntree_dst->runtime = MEM_new<bNodeTreeRuntime>(__func__);
167 bNodeTreeRuntime &dst_runtime = *ntree_dst->runtime;
168
170
171 dst_runtime.nodes_by_id.reserve(ntree_src->all_nodes().size());
172 ntree_dst->nodes.clear_no_delete();
173
174 for (const auto [i, src_node] : ntree_src->nodes.enumerate()) {
175 /* Don't find a unique name for every node, since they should have valid names already. */
176 bNode *new_node = node_copy_with_mapping(
177 ntree_dst, src_node, flag_subdata, src_node.name, src_node.identifier, socket_map);
178 /* Parent remapping below relies on persistent identifier between the old and new tree.
179 * No changes should be needed to keep identifiers unique. */
180 BLI_assert(new_node->identifier == src_node.identifier);
181 BLI_assert(ntree_dst->runtime->nodes_by_id.contains(new_node));
182 new_node->runtime->index_in_tree = i;
183 }
184
185 /* copy links */
186 ntree_dst->links.clear_no_delete();
187 for (const bNodeLink &src_link : ntree_src->links) {
188 bNodeLink *dst_link = MEM_dupalloc(&src_link);
189 dst_link->fromnode = dst_runtime.nodes_by_id.lookup_key_as(src_link.fromnode->identifier);
190 dst_link->fromsock = socket_map.lookup(src_link.fromsock);
191 dst_link->tonode = dst_runtime.nodes_by_id.lookup_key_as(src_link.tonode->identifier);
192 dst_link->tosock = socket_map.lookup(src_link.tosock);
193 BLI_assert(dst_link->tosock);
194 dst_link->tosock->link = dst_link;
195 BLI_addtail(&ntree_dst->links, dst_link);
196 }
197
198 /* update node->parent pointers */
199 for (bNode *node : ntree_dst->all_nodes()) {
200 if (node->parent) {
201 BLI_assert(ntree_src->runtime->nodes_by_id.contains(node->parent));
202 node->parent = dst_runtime.nodes_by_id.lookup_key_as(node->parent->identifier);
203 }
204 }
205
206 for (bNode *node : ntree_dst->all_nodes()) {
207 node_declaration_ensure(*ntree_dst, *node);
208 }
209
210 ntree_dst->tree_interface.copy_data(ntree_src->tree_interface, flag);
211
212 if (ntree_src->runtime->structure_type_interface) {
213 dst_runtime.structure_type_interface = std::make_unique<nodes::StructureTypeInterface>(
214 *ntree_src->runtime->structure_type_interface);
215 }
216 if (ntree_src->runtime->reference_lifetimes_info) {
217 using namespace node_tree_reference_lifetimes;
218 dst_runtime.reference_lifetimes_info = std::make_unique<ReferenceLifetimesInfo>(
219 *ntree_src->runtime->reference_lifetimes_info);
220 for (ReferenceSetInfo &reference_set : dst_runtime.reference_lifetimes_info->reference_sets) {
221 if (ELEM(reference_set.type,
225 {
226 reference_set.socket = socket_map.lookup(reference_set.socket);
227 }
228 for (auto &socket : reference_set.potential_data_origins) {
229 socket = socket_map.lookup(socket);
230 }
231 }
232 }
239
240 if (ntree_src->geometry_node_asset_traits) {
241 ntree_dst->geometry_node_asset_traits = MEM_new<GeometryNodeAssetTraits>(
242 __func__, *ntree_src->geometry_node_asset_traits);
245 }
246 if (ntree_src->compositor_node_asset_traits) {
247 ntree_dst->compositor_node_asset_traits = MEM_new<CompositorNodeAssetTraits>(
248 __func__, *ntree_src->compositor_node_asset_traits);
249 }
250
251 if (ntree_src->nested_node_refs) {
252 ntree_dst->nested_node_refs = MEM_new_array<bNestedNodeRef>(
253 size_t(ntree_src->nested_node_refs_num), __func__);
255 ntree_src->nested_node_refs, ntree_src->nested_node_refs_num, ntree_dst->nested_node_refs);
256 }
257
258 if (flag & LIB_ID_COPY_NO_PREVIEW) {
259 ntree_dst->preview = nullptr;
260 }
261 else {
262 BKE_previewimg_id_copy(&ntree_dst->id, &ntree_src->id);
263 }
264
265 ntree_dst->description = BLI_strdup_null(ntree_src->description);
266}
267
268static void ntree_free_data(ID *id)
269{
270 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
271
272 /* XXX hack! node trees should not store execution graphs at all.
273 * This should be removed when old tree types no longer require it.
274 * Currently the execution data for texture nodes remains in the tree
275 * after execution, until the node tree is updated or freed. */
276 if (ntree->runtime->execdata) {
277 switch (ntree->type) {
278 case NTREE_SHADER:
280 break;
281 case NTREE_TEXTURE:
283 ntree->runtime->execdata = nullptr;
284 break;
285 default:
286 break;
287 }
288 }
289
290 /* XXX not nice, but needed to free localized node groups properly */
292
293 ntree->links.free_no_destruct();
294
295 /* Iterate backwards because this allows for more efficient node deletion while keeping
296 * bNodeTreeRuntime::nodes_by_id valid. */
297 for (bNode &node : ntree->nodes.items_reversed_mutable()) {
298 node_free_node(ntree, node);
299 }
300
301 ntree->tree_interface.free_data();
302
303 if (ntree->id.tag & ID_TAG_LOCALIZED) {
304 BKE_libblock_free_data(&ntree->id, true);
305 }
306
307 if (ntree->geometry_node_asset_traits) {
308 MEM_SAFE_DELETE(ntree->geometry_node_asset_traits->node_tool_idname);
309 MEM_delete(ntree->geometry_node_asset_traits);
310 }
311 if (ntree->compositor_node_asset_traits) {
312 MEM_delete(ntree->compositor_node_asset_traits);
313 }
314
315 if (ntree->nested_node_refs) {
316 MEM_delete(ntree->nested_node_refs);
317 }
318
319 MEM_SAFE_DELETE(ntree->description);
320 BKE_previewimg_id_free(&ntree->id);
321 MEM_delete(ntree->runtime);
322}
323
325{
328 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
329 }));
330
331 switch (sock->type) {
332 case SOCK_OBJECT: {
333 bNodeSocketValueObject &default_value = *sock->default_value_typed<bNodeSocketValueObject>();
335 break;
336 }
337 case SOCK_IMAGE: {
338 bNodeSocketValueImage &default_value = *sock->default_value_typed<bNodeSocketValueImage>();
340 break;
341 }
342 case SOCK_COLLECTION: {
343 bNodeSocketValueCollection &default_value =
344 *sock->default_value_typed<bNodeSocketValueCollection>();
346 break;
347 }
348 case SOCK_TEXTURE: {
349 bNodeSocketValueTexture &default_value =
350 *sock->default_value_typed<bNodeSocketValueTexture>();
352 break;
353 }
354 case SOCK_MATERIAL: {
355 bNodeSocketValueMaterial &default_value =
356 *sock->default_value_typed<bNodeSocketValueMaterial>();
358 break;
359 }
360 case SOCK_FONT: {
361 bNodeSocketValueFont &default_value = *sock->default_value_typed<bNodeSocketValueFont>();
363 break;
364 }
365 case SOCK_SCENE: {
366 bNodeSocketValueScene &default_value = *sock->default_value_typed<bNodeSocketValueScene>();
368 break;
369 }
370 case SOCK_TEXT_ID: {
371 bNodeSocketValueText &default_value = *sock->default_value_typed<bNodeSocketValueText>();
373 break;
374 }
375 case SOCK_MASK: {
376 bNodeSocketValueMask &default_value = *sock->default_value_typed<bNodeSocketValueMask>();
378 break;
379 }
380 case SOCK_SOUND: {
381 bNodeSocketValueSound &default_value = *sock->default_value_typed<bNodeSocketValueSound>();
383 break;
384 }
385 case SOCK_FLOAT:
386 case SOCK_VECTOR:
387 case SOCK_RGBA:
388 case SOCK_BOOLEAN:
389 case SOCK_ROTATION:
390 case SOCK_MATRIX:
391 case SOCK_INT:
392 case SOCK_STRING:
393 case SOCK_CUSTOM:
394 case SOCK_SHADER:
395 case SOCK_GEOMETRY:
396 case SOCK_MENU:
397 case SOCK_BUNDLE:
398 case SOCK_CLOSURE:
399 case SOCK_INT_VECTOR:
400 break;
401 }
402}
403
405{
407
410 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
411 }));
413 data,
414 IDP_foreach_property(node->system_properties, IDP_TYPE_FILTER_ID, [&](IDProperty *prop) {
415 BKE_lib_query_idpropertiesForeachIDLink_callback(prop, data);
416 }));
417 for (bNodeSocket &sock : node->inputs) {
419 }
420 for (bNodeSocket &sock : node->outputs) {
422 }
423
424 /* Note that this ID pointer is only a cache, it may be outdated. */
426}
427
429{
430 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
431
433 data,
434 ntree->owner_id,
436
438
439 for (bNode *node : ntree->all_nodes()) {
441 }
442
443 ntree->tree_interface.foreach_id(data);
444
445 if (ntree->runtime->eval_dependencies) {
446 for (ID *&id_ref : ntree->runtime->eval_dependencies->ids.values()) {
448 }
449 }
450}
451
452static void node_foreach_path(ID *id, BPathForeachPathData *bpath_data)
453{
454 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
455
456 switch (ntree->type) {
457 case NTREE_SHADER: {
458 for (bNode *node : ntree->all_nodes()) {
459 if (node->type_legacy == SH_NODE_SCRIPT) {
460 NodeShaderScript *nss = static_cast<NodeShaderScript *>(node->storage);
461 if (nss->mode == NODE_SCRIPT_EXTERNAL && nss->filepath[0]) {
462 BKE_bpath_foreach_path_fixed_process(bpath_data, nss->filepath, sizeof(nss->filepath));
463 }
464 }
465 else if (node->type_legacy == SH_NODE_TEX_IES) {
466 NodeShaderTexIES *ies = static_cast<NodeShaderTexIES *>(node->storage);
467 if (ies->mode == NODE_IES_EXTERNAL && ies->filepath[0]) {
468 BKE_bpath_foreach_path_fixed_process(bpath_data, ies->filepath, sizeof(ies->filepath));
469 }
470 }
471 }
472 break;
473 }
474 case NTREE_GEOMETRY: {
475 ntree->ensure_topology_cache(); /* Otherwise node->input_sockets() doesn't work. */
476 for (bNode *node : ntree->all_nodes()) {
477 for (bNodeSocket *socket : node->input_sockets()) {
478 /* Find file path input sockets. */
479 if (socket->type != SOCK_STRING) {
480 continue;
481 }
482 bNodeSocketValueString *socket_value = static_cast<bNodeSocketValueString *>(
483 socket->default_value);
484 if (socket_value->value[0] == '\0' || socket_value->subtype != PROP_FILEPATH) {
485 continue;
486 }
487
488 /* Process the file path. */
490 bpath_data, socket_value->value, sizeof(socket_value->value));
491 }
492 }
493 break;
494 }
495 default:
496 break;
497 }
498}
499
501{
502 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
503
504 ntree->ensure_topology_cache();
505 ntree->ensure_interface_cache();
506
507 for (bNode *node : ntree->all_nodes()) {
508 /* Hardcoded exception for some non-color data. Should ideally be a RNA property subtype,
509 * as this won't work with group nodes*/
510 if (node->type_legacy == SH_NODE_NORMAL_MAP ||
511 node->type_legacy == SH_NODE_VECTOR_DISPLACEMENT)
512 {
513 continue;
514 }
515
516 for (bNodeSocket *socket : node->input_sockets()) {
517 if (socket->type == SOCK_RGBA && socket->default_value) {
518 bNodeSocketValueRGBA *rgba = static_cast<bNodeSocketValueRGBA *>(socket->default_value);
519 fn.single(rgba->value);
520 }
521 /* Exception for subsurface radius which is color-like and may be outside the 0..1 range. */
522 else if (socket->type == SOCK_VECTOR && socket->default_value &&
523 (STREQ(socket->name, "Subsurface Radius") ||
524 STREQ(socket->name, "Subsurface Radius Scale") ||
525 (STREQ(node->idname, "ShaderNodeSubsurfaceScattering") &&
526 STREQ(socket->name, "Radius")) ||
527 (STREQ(node->idname, "ShaderNodeBsdfMetallic") &&
528 (STR_ELEM(socket->name, "IOR", "Extinction")))))
529 {
530 bNodeSocketValueVector *vec = static_cast<bNodeSocketValueVector *>(socket->default_value);
531 float length;
533 fn.single(radius);
534 copy_v3_v3(vec->value, radius * length);
535 }
536 }
537 /* For the RGB shader node that stores color in an output socket. */
538 for (bNodeSocket *socket : node->output_sockets()) {
539 if (socket->type == SOCK_RGBA && socket->default_value) {
540 bNodeSocketValueRGBA *rgba = static_cast<bNodeSocketValueRGBA *>(socket->default_value);
541 fn.single(rgba->value);
542 }
543 }
544
545 /* Most colors are in sockets, but a few exceptions. */
546 if (node->type_legacy == FN_NODE_INPUT_COLOR) {
547 NodeInputColor *input_color_storage = static_cast<NodeInputColor *>(node->storage);
548 fn.single(input_color_storage->color);
549 }
550 else if (ELEM(node->type_legacy, TEX_NODE_VALTORGB, SH_NODE_VALTORGB)) {
551 ColorBand *coba = static_cast<ColorBand *>(node->storage);
553 }
554 }
555
556 for (bNodeTreeInterfaceSocket *socket : ntree->interface_inputs()) {
557 const bke::bNodeSocketType *typeinfo = socket->socket_typeinfo();
558 if (typeinfo && typeinfo->type == SOCK_RGBA && socket->socket_data) {
559 bNodeSocketValueRGBA *rgba = static_cast<bNodeSocketValueRGBA *>(socket->socket_data);
560 fn.single(rgba->value);
561 }
562 }
563 for (bNodeTreeInterfaceSocket *socket : ntree->interface_outputs()) {
564 const bke::bNodeSocketType *typeinfo = socket->socket_typeinfo();
565 if (typeinfo && typeinfo->type == SOCK_RGBA && socket->socket_data) {
566 bNodeSocketValueRGBA *rgba = static_cast<bNodeSocketValueRGBA *>(socket->socket_data);
567 fn.single(rgba->value);
568 }
569 }
570}
571
572static ID **node_owner_pointer_get(ID *id, const bool debug_relationship_assert)
573{
574 if ((id->flag & ID_FLAG_EMBEDDED_DATA) == 0) {
575 return nullptr;
576 }
577 /* TODO: Sort this NO_MAIN or not for embedded node trees. See #86119. */
578 // BLI_assert((id->tag & ID_TAG_NO_MAIN) == 0);
579
580 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
581 if (debug_relationship_assert) {
582 BLI_assert(ntree->owner_id != nullptr);
583 BLI_assert(node_tree_from_id(ntree->owner_id) == ntree);
584 }
585
586 return &ntree->owner_id;
587}
588
589namespace forward_compat {
590
592{
593 for (bNode *node : ntree.all_nodes()) {
594 node->locx_legacy = node->location[0];
595 node->locy_legacy = node->location[1];
596 if (const bNode *parent = node->parent) {
597 node->locx_legacy -= parent->location[0];
598 node->locy_legacy -= parent->location[1];
599 }
600 }
601}
602
603static void write_legacy_properties(bNodeTree &ntree, Map<ID **, ID *> &r_ids_to_restore)
604{
605 switch (ntree.type) {
606 case NTREE_GEOMETRY: {
607 for (bNode *node : ntree.all_nodes()) {
608 if (node->type_legacy == GEO_NODE_TRANSFORM_GEOMETRY) {
609 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
610 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
611 }
612 else if (node->type_legacy == GEO_NODE_POINTS_TO_VOLUME) {
613 auto &storage = *static_cast<NodeGeometryPointsToVolume *>(node->storage);
614 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Resolution Mode"_ustr);
616 socket->default_value_typed<bNodeSocketValueMenu>()->value);
617 }
618 else if (node->type_legacy == GEO_NODE_TRIANGULATE) {
619 const bNodeSocket *quad_method_socket = node_find_socket(
620 *node, SOCK_IN, "Quad Method"_ustr);
621 const bNodeSocket *ngon_method_socket = node_find_socket(
622 *node, SOCK_IN, "N-gon Method"_ustr);
623 node->custom1 = quad_method_socket->default_value_typed<bNodeSocketValueMenu>()->value;
624 node->custom2 = ngon_method_socket->default_value_typed<bNodeSocketValueMenu>()->value;
625 }
626 else if (node->type_legacy == GEO_NODE_VOLUME_TO_MESH) {
627 auto &storage = *static_cast<NodeGeometryVolumeToMesh *>(node->storage);
628 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Resolution Mode"_ustr);
629 storage.resolution_mode = socket->default_value_typed<bNodeSocketValueMenu>()->value;
630 }
631 else if (node->type_legacy == GEO_NODE_FILL_CURVE) {
632 auto &storage = *static_cast<NodeGeometryCurveFill *>(node->storage);
633 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
635 socket->default_value_typed<bNodeSocketValueMenu>()->value);
636 }
637 else if (node->type_legacy == GEO_NODE_FILLET_CURVE) {
638 auto &storage = *static_cast<NodeGeometryCurveFillet *>(node->storage);
639 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
641 socket->default_value_typed<bNodeSocketValueMenu>()->value);
642 }
643 else if (node->type_legacy == GEO_NODE_RESAMPLE_CURVE) {
644 auto &storage = *static_cast<NodeGeometryCurveResample *>(node->storage);
645 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
647 socket->default_value_typed<bNodeSocketValueMenu>()->value);
648 }
649 else if (node->type_legacy == GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME) {
650 auto &storage = *static_cast<NodeGeometryDistributePointsInVolume *>(node->storage);
651 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
652 storage.mode = socket->default_value_typed<bNodeSocketValueMenu>()->value;
653 }
654 else if (node->type_legacy == GEO_NODE_MERGE_BY_DISTANCE) {
655 auto &storage = *static_cast<NodeGeometryMergeByDistance *>(node->storage);
656 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
658 socket->default_value_typed<bNodeSocketValueMenu>()->value);
659 }
660 else if (node->type_legacy == GEO_NODE_MESH_TO_VOLUME) {
661 auto &storage = *static_cast<NodeGeometryMeshToVolume *>(node->storage);
662 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Resolution Mode"_ustr);
663 storage.resolution_mode = socket->default_value_typed<bNodeSocketValueMenu>()->value;
664 }
665 else if (node->type_legacy == GEO_NODE_RAYCAST) {
666 auto &storage = *static_cast<NodeGeometryRaycast *>(node->storage);
667 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Interpolation"_ustr);
669 socket->default_value_typed<bNodeSocketValueMenu>()->value);
670 }
671 else if (node->type_legacy == GEO_NODE_REMOVE_ATTRIBUTE) {
672 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Pattern Mode"_ustr);
673 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
674 }
675 else if (node->type_legacy == GEO_NODE_SAMPLE_GRID) {
676 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Interpolation"_ustr);
677 node->custom2 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
678 }
679 else if (node->type_legacy == GEO_NODE_SCALE_ELEMENTS) {
680 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Scale Mode"_ustr);
681 node->custom2 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
682 }
683 else if (node->type_legacy == GEO_NODE_SET_CURVE_NORMAL) {
684 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
685 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
686 }
687 else if (node->type_legacy == GEO_NODE_SUBDIVISION_SURFACE) {
688 auto &storage = *static_cast<NodeGeometrySubdivisionSurface *>(node->storage);
689 const bNodeSocket *uv_smooth_socket = node_find_socket(*node, SOCK_IN, "UV Smooth"_ustr);
690 const bNodeSocket *boundary_smooth_socket = node_find_socket(
691 *node, SOCK_IN, "Boundary Smooth"_ustr);
692 storage.uv_smooth = uv_smooth_socket->default_value_typed<bNodeSocketValueMenu>()->value;
693 storage.boundary_smooth =
694 boundary_smooth_socket->default_value_typed<bNodeSocketValueMenu>()->value;
695 }
696 else if (node->type_legacy == GEO_NODE_UV_PACK_ISLANDS) {
697 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Method"_ustr);
698 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
699 }
700 else if (node->type_legacy == GEO_NODE_UV_UNWRAP) {
701 auto &storage = *static_cast<NodeGeometryUVUnwrap *>(node->storage);
702 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Method"_ustr);
704 socket->default_value_typed<bNodeSocketValueMenu>()->value);
705 }
706 else if (node->is_type("FunctionNodeMatchString"_ustr)) {
707 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Operation"_ustr);
708 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
709 }
710 else if (node->type_legacy == GEO_NODE_STRING_TO_CURVES) {
711 auto &storage = *static_cast<NodeGeometryStringToCurves *>(node->storage);
713 node_find_socket(*node, SOCK_IN, "Overflow"_ustr)
714 ->default_value_typed<bNodeSocketValueMenu>()
715 ->value);
717 node_find_socket(*node, SOCK_IN, "Align X"_ustr)
718 ->default_value_typed<bNodeSocketValueMenu>()
719 ->value);
721 node_find_socket(*node, SOCK_IN, "Align Y"_ustr)
722 ->default_value_typed<bNodeSocketValueMenu>()
723 ->value);
725 node_find_socket(*node, SOCK_IN, "Pivot Point"_ustr)
726 ->default_value_typed<bNodeSocketValueMenu>()
727 ->value);
728 r_ids_to_restore.add(&node->id, node->id);
729 node->id = id_cast<ID *>(node_find_socket(*node, SOCK_IN, "Font"_ustr)
730 ->default_value_typed<bNodeSocketValueFont>()
731 ->value);
732 }
733 else if (node->is_type("GeometryNodeMergeLayers"_ustr)) {
734 auto &storage = *static_cast<NodeGeometryMergeLayers *>(node->storage);
735 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
736 storage.mode = socket->default_value_typed<bNodeSocketValueMenu>()->value;
737 }
738 else if (node->is_type("GeometryNodeSetGreasePencilColor"_ustr)) {
739 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
740 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
741 }
742 else if (node->is_type("GeometryNodeSetGreasePencilDepth"_ustr)) {
743 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Depth Order"_ustr);
744 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
745 }
746 }
747 break;
748 }
749 case NTREE_COMPOSIT: {
750 for (bNode *node : ntree.all_nodes()) {
751 if (node->type_legacy == CMP_NODE_BLUR) {
752 auto &storage = *static_cast<NodeBlurData *>(node->storage);
753 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
754 storage.filtertype = socket->default_value_typed<bNodeSocketValueMenu>()->value;
755 }
756 else if (node->type_legacy == CMP_NODE_FILTER) {
757 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
758 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
759 }
760 else if (node->type_legacy == CMP_NODE_VIEW_LEVELS) {
761 const bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Channel"_ustr);
762 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
763 }
764 else if (node->type_legacy == CMP_NODE_DILATEERODE) {
765 const bNodeSocket *type_socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
766 node->custom1 = type_socket->default_value_typed<bNodeSocketValueMenu>()->value;
767
768 auto &storage = *static_cast<NodeDilateErode *>(node->storage);
769 const bNodeSocket *falloff_socket = node_find_socket(*node, SOCK_IN, "Falloff"_ustr);
770 storage.falloff = falloff_socket->default_value_typed<bNodeSocketValueMenu>()->value;
771 }
772 else if (node->type_legacy == CMP_NODE_TONEMAP) {
773 auto &storage = *static_cast<NodeTonemap *>(node->storage);
774 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
775 storage.type = socket->default_value_typed<bNodeSocketValueMenu>()->value;
776 }
777 else if (node->type_legacy == CMP_NODE_LENSDIST) {
778 auto &storage = *static_cast<NodeLensDist *>(node->storage);
779 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
780 storage.distortion_type = socket->default_value_typed<bNodeSocketValueMenu>()->value;
781 }
782 else if (node->type_legacy == CMP_NODE_KUWAHARA) {
783 auto &storage = *static_cast<NodeKuwaharaData *>(node->storage);
784 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
785 storage.variation = socket->default_value_typed<bNodeSocketValueMenu>()->value;
786 }
787 else if (node->type_legacy == CMP_NODE_DENOISE) {
788 auto &storage = *static_cast<NodeDenoise *>(node->storage);
789 bNodeSocket *prefilter_socket = node_find_socket(*node, SOCK_IN, "Prefilter"_ustr);
790 storage.prefilter = prefilter_socket->default_value_typed<bNodeSocketValueMenu>()->value;
791 bNodeSocket *quality_socket = node_find_socket(*node, SOCK_IN, "Quality"_ustr);
792 storage.quality = quality_socket->default_value_typed<bNodeSocketValueMenu>()->value;
793 }
794 else if (node->type_legacy == CMP_NODE_TRANSLATE) {
795 auto &storage = *static_cast<NodeTranslateData *>(node->storage);
796 bNodeSocket *interpolation_socket = node_find_socket(
797 *node, SOCK_IN, "Interpolation"_ustr);
798 storage.interpolation =
799 interpolation_socket->default_value_typed<bNodeSocketValueMenu>()->value;
800 bNodeSocket *extension_x_socket = node_find_socket(*node, SOCK_IN, "Extension X"_ustr);
801 storage.extension_x =
802 extension_x_socket->default_value_typed<bNodeSocketValueMenu>()->value;
803 bNodeSocket *extension_y_socket = node_find_socket(*node, SOCK_IN, "Extension Y"_ustr);
804 storage.extension_y =
805 extension_y_socket->default_value_typed<bNodeSocketValueMenu>()->value;
806 }
807 else if (node->type_legacy == CMP_NODE_TRANSFORM) {
808 auto &storage = *static_cast<NodeTransformData *>(node->storage);
809 bNodeSocket *interpolation_socket = node_find_socket(
810 *node, SOCK_IN, "Interpolation"_ustr);
811 storage.interpolation =
812 interpolation_socket->default_value_typed<bNodeSocketValueMenu>()->value;
813 bNodeSocket *extension_x_socket = node_find_socket(*node, SOCK_IN, "Extension X"_ustr);
814 storage.extension_x =
815 extension_x_socket->default_value_typed<bNodeSocketValueMenu>()->value;
816 bNodeSocket *extension_y_socket = node_find_socket(*node, SOCK_IN, "Extension Y"_ustr);
817 storage.extension_y =
818 extension_y_socket->default_value_typed<bNodeSocketValueMenu>()->value;
819 }
820 else if (node->type_legacy == CMP_NODE_CORNERPIN) {
821 auto &storage = *static_cast<NodeCornerPinData *>(node->storage);
822 bNodeSocket *interpolation_socket = node_find_socket(
823 *node, SOCK_IN, "Interpolation"_ustr);
824 storage.interpolation =
825 interpolation_socket->default_value_typed<bNodeSocketValueMenu>()->value;
826 bNodeSocket *extension_x_socket = node_find_socket(*node, SOCK_IN, "Extension X"_ustr);
827 storage.extension_x =
828 extension_x_socket->default_value_typed<bNodeSocketValueMenu>()->value;
829 bNodeSocket *extension_y_socket = node_find_socket(*node, SOCK_IN, "Extension Y"_ustr);
830 storage.extension_y =
831 extension_y_socket->default_value_typed<bNodeSocketValueMenu>()->value;
832 }
833 else if (node->type_legacy == CMP_NODE_MAP_UV) {
834 auto &storage = *static_cast<NodeMapUVData *>(node->storage);
835 bNodeSocket *interpolation_socket = node_find_socket(
836 *node, SOCK_IN, "Interpolation"_ustr);
837 storage.interpolation =
838 interpolation_socket->default_value_typed<bNodeSocketValueMenu>()->value;
839 bNodeSocket *extension_x_socket = node_find_socket(*node, SOCK_IN, "Extension X"_ustr);
840 storage.extension_x =
841 extension_x_socket->default_value_typed<bNodeSocketValueMenu>()->value;
842 bNodeSocket *extension_y_socket = node_find_socket(*node, SOCK_IN, "Extension Y"_ustr);
843 storage.extension_y =
844 extension_y_socket->default_value_typed<bNodeSocketValueMenu>()->value;
845 }
846 else if (node->type_legacy == CMP_NODE_SCALE) {
847 bNodeSocket *type_socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
848 node->custom1 = type_socket->default_value_typed<bNodeSocketValueMenu>()->value;
849 bNodeSocket *frame_type_socket = node_find_socket(*node, SOCK_IN, "Frame Type"_ustr);
850 node->custom2 = frame_type_socket->default_value_typed<bNodeSocketValueMenu>()->value;
851
852 auto &storage = *static_cast<NodeScaleData *>(node->storage);
853 bNodeSocket *interpolation_socket = node_find_socket(
854 *node, SOCK_IN, "Interpolation"_ustr);
855 storage.interpolation =
856 interpolation_socket->default_value_typed<bNodeSocketValueMenu>()->value;
857 bNodeSocket *extension_x_socket = node_find_socket(*node, SOCK_IN, "Extension X"_ustr);
858 storage.extension_x =
859 extension_x_socket->default_value_typed<bNodeSocketValueMenu>()->value;
860 bNodeSocket *extension_y_socket = node_find_socket(*node, SOCK_IN, "Extension Y"_ustr);
861 storage.extension_y =
862 extension_y_socket->default_value_typed<bNodeSocketValueMenu>()->value;
863 }
864 else if (node->type_legacy == CMP_NODE_ROTATE) {
865 auto &storage = *static_cast<NodeRotateData *>(node->storage);
866 bNodeSocket *interpolation_socket = node_find_socket(
867 *node, SOCK_IN, "Interpolation"_ustr);
868 storage.interpolation =
869 interpolation_socket->default_value_typed<bNodeSocketValueMenu>()->value;
870 bNodeSocket *extension_x_socket = node_find_socket(*node, SOCK_IN, "Extension X"_ustr);
871 storage.extension_x =
872 extension_x_socket->default_value_typed<bNodeSocketValueMenu>()->value;
873 bNodeSocket *extension_y_socket = node_find_socket(*node, SOCK_IN, "Extension Y"_ustr);
874 storage.extension_y =
875 extension_y_socket->default_value_typed<bNodeSocketValueMenu>()->value;
876 }
877 else if (node->type_legacy == CMP_NODE_DISPLACE) {
878 auto &storage = *static_cast<NodeDisplaceData *>(node->storage);
879 bNodeSocket *interpolation_socket = node_find_socket(
880 *node, SOCK_IN, "Interpolation"_ustr);
881 storage.interpolation =
882 interpolation_socket->default_value_typed<bNodeSocketValueMenu>()->value;
883 bNodeSocket *extension_x_socket = node_find_socket(*node, SOCK_IN, "Extension X"_ustr);
884 storage.extension_x =
885 extension_x_socket->default_value_typed<bNodeSocketValueMenu>()->value;
886 bNodeSocket *extension_y_socket = node_find_socket(*node, SOCK_IN, "Extension Y"_ustr);
887 storage.extension_y =
888 extension_y_socket->default_value_typed<bNodeSocketValueMenu>()->value;
889 }
890 else if (node->type_legacy == CMP_NODE_STABILIZE2D) {
891 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Interpolation"_ustr);
892 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
893 }
894 else if (node->type_legacy == CMP_NODE_MASK_BOX) {
895 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Operation"_ustr);
896 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
897 }
898 else if (node->type_legacy == CMP_NODE_MASK_ELLIPSE) {
899 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Operation"_ustr);
900 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
901 }
902 else if (node->type_legacy == CMP_NODE_TRACKPOS) {
903 bNodeSocket *mode_socket = node_find_socket(*node, SOCK_IN, "Mode"_ustr);
904 node->custom1 = mode_socket->default_value_typed<bNodeSocketValueMenu>()->value;
905 bNodeSocket *frame_socket = node_find_socket(*node, SOCK_IN, "Frame"_ustr);
906 node->custom2 = frame_socket->default_value_typed<bNodeSocketValueInt>()->value;
907 }
908 else if (node->type_legacy == CMP_NODE_KEYING) {
909 auto &storage = *static_cast<NodeKeyingData *>(node->storage);
910 bNodeSocket *feather_falloff_socket = node_find_socket(
911 *node, SOCK_IN, "Feather Falloff"_ustr);
912 storage.feather_falloff =
913 feather_falloff_socket->default_value_typed<bNodeSocketValueMenu>()->value;
914 }
915 else if (node->type_legacy == CMP_NODE_MASK) {
916 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Size Source"_ustr);
917 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
918 }
919 else if (node->type_legacy == CMP_NODE_MOVIEDISTORTION) {
920 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
921 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
922 }
923 else if (node->type_legacy == CMP_NODE_GLARE) {
924 auto &storage = *static_cast<NodeGlare *>(node->storage);
925 bNodeSocket *type_socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
926 storage.type = type_socket->default_value_typed<bNodeSocketValueMenu>()->value;
927 bNodeSocket *quality_socket = node_find_socket(*node, SOCK_IN, "Quality"_ustr);
928 storage.quality = quality_socket->default_value_typed<bNodeSocketValueMenu>()->value;
929 }
930 else if (node->type_legacy == CMP_NODE_SETALPHA) {
931 auto &storage = *static_cast<NodeSetAlpha *>(node->storage);
932 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
933 storage.mode = socket->default_value_typed<bNodeSocketValueMenu>()->value;
934 }
935 else if (node->type_legacy == CMP_NODE_CHANNEL_MATTE) {
936 auto &storage = *static_cast<NodeChroma *>(node->storage);
937 bNodeSocket *color_space_socket = node_find_socket(*node, SOCK_IN, "Color Space"_ustr);
938 node->custom1 = color_space_socket->default_value_typed<bNodeSocketValueMenu>()->value +
939 1;
940
941 switch (CMPNodeChannelMatteColorSpace(node->custom1 - 1)) {
943 bNodeSocket *channel_socket = node_find_socket(
944 *node, SOCK_IN, "RGB Key Channel"_ustr);
945 node->custom2 = channel_socket->default_value_typed<bNodeSocketValueMenu>()->value +
946 1;
947 break;
948 }
950 bNodeSocket *channel_socket = node_find_socket(
951 *node, SOCK_IN, "HSV Key Channel"_ustr);
952 node->custom2 = channel_socket->default_value_typed<bNodeSocketValueMenu>()->value +
953 1;
954 break;
955 }
957 bNodeSocket *channel_socket = node_find_socket(
958 *node, SOCK_IN, "YUV Key Channel"_ustr);
959 node->custom2 = channel_socket->default_value_typed<bNodeSocketValueMenu>()->value +
960 1;
961 break;
962 }
964 bNodeSocket *channel_socket = node_find_socket(
965 *node, SOCK_IN, "YCbCr Key Channel"_ustr);
966 node->custom2 = channel_socket->default_value_typed<bNodeSocketValueMenu>()->value +
967 1;
968 break;
969 }
970 }
971
972 bNodeSocket *limit_method_socket = node_find_socket(*node, SOCK_IN, "Limit Method"_ustr);
973 storage.algorithm =
974 limit_method_socket->default_value_typed<bNodeSocketValueMenu>()->value;
975
976 switch (CMPNodeChannelMatteColorSpace(node->custom1 - 1)) {
978 bNodeSocket *channel_socket = node_find_socket(
979 *node, SOCK_IN, "RGB Limit Channel"_ustr);
980 storage.channel =
981 channel_socket->default_value_typed<bNodeSocketValueMenu>()->value + 1;
982 break;
983 }
985 bNodeSocket *channel_socket = node_find_socket(
986 *node, SOCK_IN, "HSV Limit Channel"_ustr);
987 storage.channel =
988 channel_socket->default_value_typed<bNodeSocketValueMenu>()->value + 1;
989 break;
990 }
992 bNodeSocket *channel_socket = node_find_socket(
993 *node, SOCK_IN, "YUV Limit Channel"_ustr);
994 storage.channel =
995 channel_socket->default_value_typed<bNodeSocketValueMenu>()->value + 1;
996 break;
997 }
999 bNodeSocket *channel_socket = node_find_socket(
1000 *node, SOCK_IN, "YCbCr Limit Channel"_ustr);
1001 storage.channel =
1002 channel_socket->default_value_typed<bNodeSocketValueMenu>()->value + 1;
1003 break;
1004 }
1005 }
1006 }
1007 else if (node->type_legacy == CMP_NODE_COLORBALANCE) {
1008 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
1009 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
1010 }
1011 else if (node->type_legacy == CMP_NODE_PREMULKEY) {
1012 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Type"_ustr);
1013 node->custom1 = socket->default_value_typed<bNodeSocketValueMenu>()->value;
1014 }
1015 else if (node->type_legacy == CMP_NODE_DIST_MATTE) {
1016 auto &storage = *static_cast<NodeChroma *>(node->storage);
1017 bNodeSocket *socket = node_find_socket(*node, SOCK_IN, "Color Space"_ustr);
1018 storage.channel = socket->default_value_typed<bNodeSocketValueMenu>()->value + 1;
1019 }
1020 else if (node->type_legacy == CMP_NODE_COLOR_SPILL) {
1021 bNodeSocket *spill_channel_socket = node_find_socket(
1022 *node, SOCK_IN, "Spill Channel"_ustr);
1023 node->custom1 =
1024 spill_channel_socket->default_value_typed<bNodeSocketValueMenu>()->value + 1;
1025
1026 bNodeSocket *limit_method_socket = node_find_socket(*node, SOCK_IN, "Limit Method"_ustr);
1027 node->custom2 = limit_method_socket->default_value_typed<bNodeSocketValueMenu>()->value;
1028
1029 auto &storage = *static_cast<NodeColorspill *>(node->storage);
1030 bNodeSocket *limit_channel_socket = node_find_socket(
1031 *node, SOCK_IN, "Limit Channel"_ustr);
1032 storage.limchan =
1033 limit_channel_socket->default_value_typed<bNodeSocketValueMenu>()->value;
1034 }
1035 else if (node->type_legacy == CMP_NODE_DOUBLEEDGEMASK) {
1036 bNodeSocket *image_edges_socket = node_find_socket(*node, SOCK_IN, "Image Edges"_ustr);
1037 node->custom2 = bool(
1038 image_edges_socket->default_value_typed<bNodeSocketValueBoolean>()->value);
1039
1040 bNodeSocket *only_inside_outer_socket = node_find_socket(
1041 *node, SOCK_IN, "Only Inside Outer"_ustr);
1042 node->custom1 = bool(
1043 only_inside_outer_socket->default_value_typed<bNodeSocketValueBoolean>()->value);
1044 }
1045 }
1046 }
1047 default:
1048 break;
1049 }
1050}
1051
1052/* The NodeImageLayer storage for the output sockets were removed, so they need to be allocated
1053 * again and their pass name set to the identifier. Those need to be freed again after writing by
1054 * calling free_legacy_socket_storage. */
1056{
1057 if (ELEM(node.type_legacy, CMP_NODE_R_LAYERS, CMP_NODE_IMAGE)) {
1058 for (bNodeSocket &output : node.outputs) {
1059 NodeImageLayer *storage = MEM_new<NodeImageLayer>(__func__);
1060 output.storage = storage;
1061 /* Alpha is derived from the combined pass. */
1062 if (STREQ(output.identifier, "Alpha")) {
1064 }
1065 else {
1066 STRNCPY_UTF8(storage->pass_name, output.identifier);
1067 }
1068 }
1069 }
1070}
1071
1072/* See initialize_legacy_socket_storage. */
1074{
1075 if (ELEM(node.type_legacy, CMP_NODE_R_LAYERS, CMP_NODE_IMAGE)) {
1076 for (bNodeSocket &output : node.outputs) {
1077 if (output.storage) {
1078 MEM_delete(static_cast<NodeImageLayer *>(output.storage));
1079 output.storage = nullptr;
1080 }
1081 }
1082 }
1083}
1084
1086{
1087 static const Map<StringRef, StringRef> map = {
1088 {"NodeSocketFloatPixel", "NodeSocketFloat"},
1089 {"NodeSocketVectorPixel", "NodeSocketVector"},
1090 {"NodeSocketVectorPixel2D", "NodeSocketVector2D"},
1091 {"NodeSocketVectorPixel4D", "NodeSocketVector4D"},
1092 {"NodeSocketIntPixel", "NodeSocketInt"},
1093 {"NodeSocketIntVectorPixel2D", "NodeSocketIntVector2D"},
1094 {"NodeSocketIntVectorPixel3D", "NodeSocketIntVector3D"}};
1095 return map;
1096}
1097
1098template<typename ValueType>
1099static void write_default_value_none_subtype(BlendWriter *writer, const void *default_value)
1100{
1101 writer->write_struct_cast<ValueType>(default_value,
1102 [](BlendStructWriter<ValueType> &struct_writer) {
1103 struct_writer.shallow_data.subtype = PROP_NONE;
1104 });
1105}
1106
1108{
1109 bNodeSocket *sock_copy = MEM_dupalloc(&sock);
1111 STRNCPY(sock_copy->idname, subtype_pixel_to_none().lookup(sock.idname).data());
1112
1113 /* This property should only be used for group node "interface" sockets. */
1114 BLI_assert(sock_copy->default_attribute_name == nullptr);
1115
1116 /* Write a shallow copy of sock to ensure modified #sock->default_value is written at desired
1117 * original address, see also #write_default_value_none_subtype. This is safe because sockets
1118 * with Pixel and None subtypes share the same data. */
1119 void *default_value_copy = sock_copy->default_value;
1120 IDProperty *prop_copy = sock_copy->prop;
1121 sock_copy->default_value = sock.default_value;
1122 sock_copy->prop = sock.prop;
1124 &sock, sock_copy, [](BlendStructWriter<bNodeSocket> &struct_writer) {
1125 struct_writer.shallow_data.runtime = nullptr;
1126 struct_writer.shallow_data.typeinfo = nullptr;
1127 });
1128 sock_copy->default_value = default_value_copy;
1129 sock_copy->prop = prop_copy;
1130
1131 if (sock.prop) {
1132 IDP_BlendWrite(writer, sock.prop);
1133 }
1134
1135 if (sock.default_value != nullptr) {
1136 switch (sock.type) {
1137 case SOCK_FLOAT:
1139 break;
1140 case SOCK_VECTOR:
1142 break;
1143 case SOCK_INT:
1145 break;
1146 case SOCK_INT_VECTOR:
1148 break;
1149 default:
1151 break;
1152 }
1153 }
1154
1155 node_socket_free(sock_copy, false);
1156 MEM_delete(sock_copy);
1157}
1158
1159} // namespace forward_compat
1160
1162{
1163 if (sock->default_value == nullptr) {
1164 return;
1165 }
1166
1167 switch (sock->type) {
1168 case SOCK_FLOAT:
1170 break;
1171 case SOCK_VECTOR:
1173 break;
1174 case SOCK_RGBA:
1176 break;
1177 case SOCK_BOOLEAN:
1179 break;
1180 case SOCK_INT:
1182 break;
1183 case SOCK_STRING:
1185 break;
1186 case SOCK_OBJECT:
1188 break;
1189 case SOCK_IMAGE:
1191 break;
1192 case SOCK_COLLECTION:
1194 break;
1195 case SOCK_TEXTURE:
1197 break;
1198 case SOCK_MATERIAL:
1200 break;
1201 case SOCK_FONT:
1203 break;
1204 case SOCK_SCENE:
1206 break;
1207 case SOCK_TEXT_ID:
1209 break;
1210 case SOCK_MASK:
1212 break;
1213 case SOCK_SOUND:
1215 break;
1216 case SOCK_ROTATION:
1218 break;
1219 case SOCK_MENU:
1221 break;
1222 case SOCK_INT_VECTOR:
1224 break;
1225 case SOCK_MATRIX:
1226 /* Matrix sockets currently have no default value. */
1227 break;
1228 case SOCK_CUSTOM:
1229 /* Custom node sockets where default_value is defined use custom properties for storage. */
1230 break;
1231 case SOCK_SHADER:
1232 case SOCK_GEOMETRY:
1233 case SOCK_BUNDLE:
1234 case SOCK_CLOSURE:
1236 break;
1237 }
1238}
1239
1240static void write_node_socket(BlendWriter *writer, const bNodeSocket *sock)
1241{
1242 /* Todo(#140111): Forward compatibility support for pixel subtype will be removed in 6.0. */
1243 if (!writer->is_undo() && forward_compat::subtype_pixel_to_none().contains(sock->idname)) {
1245 return;
1246 }
1247
1248 writer->write_struct(sock, [](BlendStructWriter<bNodeSocket> &struct_writer) {
1249 struct_writer.shallow_data.runtime = nullptr;
1250 struct_writer.shallow_data.typeinfo = nullptr;
1251 });
1252
1253 if (sock->prop) {
1254 IDP_BlendWrite(writer, sock->prop);
1255 }
1256
1257 /* This property should only be used for group node "interface" sockets. */
1258 BLI_assert(sock->default_attribute_name == nullptr);
1259
1260 write_node_socket_default_value(writer, sock);
1261}
1262
1264{
1265 if (!node->storage) {
1266 return;
1267 }
1268
1269 if (node->type_legacy == CMP_NODE_GLARE) {
1270 /* Simple forward compatibility for fix for #50736.
1271 * Not ideal (there is no ideal solution here), but should do for now. */
1272 NodeGlare *ndg = static_cast<NodeGlare *>(node->storage);
1273 /* Not in undo case. */
1274 if (!writer->is_undo()) {
1275 switch (ndg->type) {
1277 ndg->angle = ndg->streaks;
1278 break;
1280 ndg->angle = ndg->star_45;
1281 break;
1282 default:
1283 break;
1284 }
1285 }
1286 }
1287 else if (node->type_legacy == GEO_NODE_CAPTURE_ATTRIBUTE) {
1288 auto &storage = *static_cast<NodeGeometryAttributeCapture *>(node->storage);
1289 /* Improve forward compatibility. */
1290 storage.data_type_legacy = CD_PROP_FLOAT;
1291 for (const NodeGeometryAttributeCaptureItem &item :
1292 Span{storage.capture_items, storage.capture_items_num})
1293 {
1294 if (item.identifier == 0) {
1295 /* The sockets of this item have the same identifiers that have been used by older
1296 * Blender versions before the node supported capturing multiple attributes. */
1297 storage.data_type_legacy = item.data_type;
1298 break;
1299 }
1300 }
1301 }
1302 else if (node->type_legacy == GEO_NODE_VIEWER) {
1303 /* Forward compatibility for older Blender versions where the viewer node only had a geometry
1304 * and field input. */
1305 auto &storage = *static_cast<NodeGeometryViewer *>(node->storage);
1306 for (const NodeGeometryViewerItem &item : Span{storage.items, storage.items_num}) {
1307 if (ELEM(item.socket_type,
1308 SOCK_FLOAT,
1309 SOCK_INT,
1311 SOCK_RGBA,
1314 SOCK_MATRIX))
1315 {
1316 storage.data_type_legacy = *socket_type_to_custom_data_type(item.socket_type);
1317 break;
1318 }
1319 }
1320 }
1321
1322 const bNodeType *ntype = node->typeinfo;
1323 if (!ntype->storagename.empty()) {
1324 writer->write_struct_by_name(ntype->storagename.c_str(), node->storage);
1325 }
1326 if (ntype->blend_write_storage_content) {
1327 ntype->blend_write_storage_content(*ntree, *node, *writer);
1328 return;
1329 }
1330
1331 /* These nodes don't use #blend_write_storage_content because their corresponding blend-read
1332 * can't use it since they were introduced before there were node idnames. */
1333 if (ELEM(node->type_legacy,
1343 {
1344 BKE_curvemapping_curves_blend_write(writer, static_cast<const CurveMapping *>(node->storage));
1345 }
1346 else if (node->type_legacy == SH_NODE_SCRIPT) {
1347 NodeShaderScript *nss = static_cast<NodeShaderScript *>(node->storage);
1348 if (nss->bytecode) {
1349 writer->write_string(nss->bytecode);
1350 }
1351 }
1352 else if (ELEM(node->type_legacy, CMP_NODE_CRYPTOMATTE, CMP_NODE_CRYPTOMATTE_LEGACY)) {
1353 NodeCryptomatte *nc = static_cast<NodeCryptomatte *>(node->storage);
1354 writer->write_string(nc->matte_id);
1355 for (CryptomatteEntry &entry : nc->entries) {
1356 writer->write_struct(&entry);
1357 }
1358 }
1359}
1360
1362{
1363 BKE_id_blend_write(writer, &ntree->id);
1364 writer->write_string(ntree->description);
1365
1366 /* Restore IDs overridden for forward compatibility. Otherwise their user count becomes wrong. */
1367 Map<ID **, ID *> ids_to_restore;
1368 if (!writer->is_undo()) {
1370 forward_compat::write_legacy_properties(*ntree, ids_to_restore);
1371 }
1372
1373 for (bNode *node : ntree->all_nodes()) {
1374 if (ntree->type == NTREE_SHADER && node->type_legacy == SH_NODE_BSDF_HAIR_PRINCIPLED) {
1375 /* For Principled Hair BSDF, also write to `node->custom1` for forward compatibility, because
1376 * prior to 4.0 `node->custom1` was used for color parametrization instead of
1377 * `node->storage->parametrization`. */
1378 NodeShaderHairPrincipled *data = static_cast<NodeShaderHairPrincipled *>(node->storage);
1379 node->custom1 = data->parametrization;
1380 }
1381
1382 writer->write_struct(node, [](BlendStructWriter<bNode> &struct_writer) {
1383 bNode &shallow_node = struct_writer.shallow_data;
1384 shallow_node.runtime = nullptr;
1385 shallow_node.typeinfo = nullptr;
1386 if (shallow_node.num_panel_states == 0) {
1387 shallow_node.panel_states_array = nullptr;
1388 }
1389 });
1390
1391 if (node->prop) {
1392 IDP_BlendWrite(writer, node->prop);
1393 }
1394 if (node->system_properties) {
1395 IDP_BlendWrite(writer, node->system_properties);
1396 }
1397
1398 if (!writer->is_undo()) {
1400 }
1401
1402 for (bNodeSocket &sock : node->inputs) {
1403 write_node_socket(writer, &sock);
1404 }
1405 for (bNodeSocket &sock : node->outputs) {
1406 write_node_socket(writer, &sock);
1407 }
1408 writer->write_struct_array(node->num_panel_states, node->panel_states_array);
1409
1410 if (node->storage) {
1411 node_blend_write_storage(writer, ntree, node);
1412 }
1413
1414 if (ELEM(node->type_legacy, CMP_NODE_IMAGE, CMP_NODE_R_LAYERS)) {
1415 /* Write extra socket info. */
1416 for (bNodeSocket &sock : node->outputs) {
1418 }
1419 }
1420 }
1421
1422 for (const bNodeLink &link : ntree->links) {
1423 writer->write_struct(&link);
1424 }
1425
1426 ntree->tree_interface.write(writer);
1427
1429 if (ntree->geometry_node_asset_traits) {
1431 }
1433
1435
1436 BKE_previewimg_blend_write(writer, ntree->preview);
1437
1438 /* Freeing temporary allocations needs to happen at the very end, because if we free after the
1439 * data is no longer needed, future allocations might be given the same address by the OS, which
1440 * will produce a corrupt blend file because multiple data use the same identifier/address in the
1441 * same ID. */
1442 if (!writer->is_undo()) {
1443 for (bNode *node : ntree->all_nodes()) {
1445 }
1446 for (const auto &item : ids_to_restore.items()) {
1447 *item.key = item.value;
1448 }
1449 }
1450}
1451
1452static void ntree_blend_write(BlendWriter *writer, ID *id, const void *id_address)
1453{
1454 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
1455
1456 /* Clean up, important in undo case to reduce false detection of changed datablocks. */
1457 ntree->typeinfo = nullptr;
1458 ntree->runtime->execdata = nullptr;
1459
1460 writer->write_id_struct(id_address, ntree);
1461
1462 node_tree_blend_write(writer, ntree);
1463}
1464
1471{
1472 switch (sock->type) {
1473 case SOCK_FLOAT:
1474 case SOCK_VECTOR:
1475 case SOCK_RGBA:
1476 case SOCK_BOOLEAN:
1477 case SOCK_INT:
1478 case SOCK_STRING:
1479 case SOCK_CUSTOM:
1480 case SOCK_SHADER:
1481 case SOCK_GEOMETRY:
1482 case SOCK_OBJECT:
1483 case SOCK_IMAGE:
1484 case SOCK_COLLECTION:
1485 case SOCK_TEXTURE:
1486 case SOCK_MATERIAL:
1487 case SOCK_FONT:
1488 case SOCK_SCENE:
1489 case SOCK_TEXT_ID:
1490 case SOCK_MASK:
1491 case SOCK_SOUND:
1492 case SOCK_ROTATION:
1493 case SOCK_MENU:
1494 case SOCK_MATRIX:
1495 case SOCK_BUNDLE:
1496 case SOCK_CLOSURE:
1497 case SOCK_INT_VECTOR:
1498 return true;
1499 }
1500 return false;
1501}
1502
1504
1505/* Specific code required to properly handle older blend-files (pre-2.83), where some node data
1506 * (like the sockets default values) were written as raw bytes buffer, without any DNA type
1507 * information. */
1508
1509/* Node socket default values were historically written and read as raw bytes buffers, without any
1510 * DNA typing information.
1511 *
1512 * The writing code was fixed in commit `50d5050e9c`, which is included in the 2.83 release.
1513 * However the matching reading code was only fixed in the 4.5 release.
1514 *
1515 * So currently, reading code assumes that any blend-file >= 3.0 has correct DNA info for these
1516 * default values, and it keeps previous 'raw buffer' reading code for older ones.
1517 *
1518 * This means that special care must be taken when the various DNA types used for these default
1519 * values are modified, as a 'manual' version of DNA internal versioning must be performed on data
1520 * from older blend-files (see also #direct_link_node_socket_default_value).
1521 */
1523
1524/* The `_404` structs below are copies of DNA structs as they were in Blender 4.4 and before. Their
1525 * data layout should never have to be modified in any way, as it matches the expected data layout
1526 * in the raw bytes buffers read from older blend-files.
1527 *
1528 * NOTE: There is _no_ need to protect DNA structs definition in any way to ensure forward
1529 * compatibility, for the following reasons:
1530 * - The DNA struct info _is_ properly written in blend-files since 2.83.
1531 * - When there is DNA info for a #BHead in the blend-file, even if that #BHead is ultimately
1532 * 'read'/used as raw bytes buffer through a call to `BLO_read_raw_address`, the actual
1533 * reading of that #BHead from the blend-file will have already gone through the lower-level
1534 * 'DNA versioning' process, which means that DNA struct changes (like adding new properties,
1535 * increasing an array size, etc.) will be handled properly.
1536 * - Blender versions prior to 3.6 will not be able to load any 4.0+ blend-files without
1537 * immediate crash, so trying to preserve forward compatibility for versions older than
1538 * 2.83 would be totally pointless.
1539 */
1540
1547
1554
1558
1562 float value[3];
1563 float min, max;
1564};
1565
1569
1571 float value[4];
1572};
1573
1576 char _pad[4];
1577 char value[/*FILE_MAX*/ 1024];
1578};
1579
1583
1587
1591
1595
1599
1601 /* Default input enum identifier. */
1603 /* #NodeSocketValueMenuRuntimeFlag */
1605 /* Immutable runtime enum definition. */
1607};
1608
1609/* Generic code handling the conversion between a legacy (pre-2.83) socket data, and its current
1610 * data. Currently used for `bNodeSocket.default_value`. */
1611template<typename T, typename T_404>
1613 void **dest_data, void **raw_data, FunctionRef<void(T &dest, T_404 &source)> copy_fn)
1614{
1615 /* Cannot check for equality because of potential alignment offset. */
1616 BLI_assert(MEM_allocN_len(*raw_data) >= sizeof(T_404));
1617 T_404 *orig_data = static_cast<T_404 *>(*raw_data);
1618 *raw_data = nullptr;
1619 T *final_data = MEM_new<T>(__func__);
1620 /* Could use `memcpy` here, since we also require historic members of these DNA structs to
1621 * never be moved or re-ordered. But better be verbose and explicit here. */
1622 copy_fn(*final_data, *orig_data);
1623 *dest_data = final_data;
1624 MEM_delete(orig_data);
1625}
1626
1627} // namespace versioning_internal
1628
1630{
1631 if (sock->default_value == nullptr) {
1632 return;
1633 }
1634
1635 if (sock->type == SOCK_CUSTOM) {
1636 /* There are some files around that have non-null default value for custom sockets. See e.g.
1637 * #140083.
1638 *
1639 * It is unclear how this could happen, but for now simply systematically set this pointer to
1640 * null. */
1641 sock->default_value = nullptr;
1642 return;
1643 }
1644
1645 if (BLO_read_fileversion_get(reader) >=
1647 {
1648 /* Modern, standard DNA-typed reading of sockets default values. */
1649 switch (sock->type) {
1650 case SOCK_FLOAT:
1652 break;
1653 case SOCK_VECTOR:
1655 break;
1656 case SOCK_RGBA:
1658 break;
1659 case SOCK_BOOLEAN:
1661 break;
1662 case SOCK_INT:
1664 break;
1665 case SOCK_STRING:
1667 break;
1668 case SOCK_OBJECT:
1670 break;
1671 case SOCK_IMAGE:
1673 break;
1674 case SOCK_COLLECTION:
1676 break;
1677 case SOCK_TEXTURE:
1679 break;
1680 case SOCK_MATERIAL:
1682 break;
1683 case SOCK_FONT:
1685 break;
1686 case SOCK_SCENE:
1688 break;
1689 case SOCK_TEXT_ID:
1691 break;
1692 case SOCK_MASK:
1694 break;
1695 case SOCK_SOUND:
1697 break;
1698 case SOCK_ROTATION:
1700 break;
1701 case SOCK_MENU:
1703 break;
1704 case SOCK_INT_VECTOR:
1706 break;
1707 case SOCK_MATRIX:
1708 /* Matrix sockets currently have no default value. */
1709 case SOCK_CUSTOM:
1710 /* Custom node sockets where default_value is defined use custom properties for storage. */
1711 case SOCK_SHADER:
1712 case SOCK_GEOMETRY:
1713 case SOCK_BUNDLE:
1714 case SOCK_CLOSURE:
1716 break;
1717 }
1718 }
1719 else {
1720 /* Legacy-compatible, raw-buffer-based reading of sockets default values. */
1721 void *temp_data = sock->default_value;
1722 BLO_read_raw_address(reader, &temp_data);
1723 if (!temp_data) {
1724 sock->default_value = nullptr;
1725 return;
1726 }
1727
1728 switch (sock->type) {
1729 case SOCK_FLOAT:
1733 &sock->default_value,
1734 &temp_data,
1736 dest.subtype = src.subtype;
1737 dest.value = src.value;
1738 dest.min = src.min;
1739 dest.max = src.max;
1740 });
1741 break;
1742 case SOCK_VECTOR:
1746 &sock->default_value,
1747 &temp_data,
1748 [](bNodeSocketValueVector &dest,
1750 dest.subtype = src.subtype;
1751 copy_v3_v3(dest.value, src.value);
1752 dest.min = src.min;
1753 dest.max = src.max;
1754 });
1755 break;
1756 case SOCK_RGBA:
1760 &sock->default_value,
1761 &temp_data,
1763 copy_v4_v4(dest.value, src.value);
1764 });
1765 break;
1766 case SOCK_BOOLEAN:
1770 &sock->default_value,
1771 &temp_data,
1772 [](bNodeSocketValueBoolean &dest,
1773 versioning_internal::bNodeSocketValueBoolean_404 &src) { dest.value = src.value; });
1774 break;
1775 case SOCK_INT:
1779 &sock->default_value,
1780 &temp_data,
1782 dest.subtype = src.subtype;
1783 dest.value = src.value;
1784 dest.min = src.min;
1785 dest.max = src.max;
1786 });
1787 break;
1788 case SOCK_STRING:
1792 &sock->default_value,
1793 &temp_data,
1794 [](bNodeSocketValueString &dest,
1796 dest.subtype = src.subtype;
1797 STRNCPY(dest.value, src.value);
1798 });
1799 break;
1800 case SOCK_OBJECT:
1804 &sock->default_value,
1805 &temp_data,
1806 [](bNodeSocketValueObject &dest,
1807 versioning_internal::bNodeSocketValueObject_404 &src) { dest.value = src.value; });
1808 break;
1809 case SOCK_IMAGE:
1813 &sock->default_value,
1814 &temp_data,
1816 dest.value = src.value;
1817 });
1818 break;
1819 case SOCK_COLLECTION:
1823 &sock->default_value,
1824 &temp_data,
1827 dest.value = src.value;
1828 });
1829 break;
1830 case SOCK_TEXTURE:
1834 &sock->default_value,
1835 &temp_data,
1836 [](bNodeSocketValueTexture &dest,
1837 versioning_internal::bNodeSocketValueTexture_404 &src) { dest.value = src.value; });
1838 break;
1839 case SOCK_MATERIAL:
1843 &sock->default_value,
1844 &temp_data,
1845 [](bNodeSocketValueMaterial &dest,
1847 dest.value = src.value;
1848 });
1849 break;
1850 case SOCK_ROTATION:
1854 &sock->default_value,
1855 &temp_data,
1856 [](bNodeSocketValueRotation &dest,
1858 copy_v3_v3(dest.value_euler, src.value_euler);
1859 });
1860 break;
1861 case SOCK_MENU:
1865 &sock->default_value,
1866 &temp_data,
1868 dest.value = src.value;
1869 /* Other members are runtime-only. */
1870 });
1871 break;
1872 case SOCK_MATRIX:
1873 /* Matrix sockets had no default value. */
1874 case SOCK_CUSTOM:
1875 /* Custom node sockets where default_value is defined were using custom properties for
1876 * storage. */
1877 case SOCK_FONT:
1878 case SOCK_SCENE:
1879 case SOCK_TEXT_ID:
1880 case SOCK_MASK:
1881 case SOCK_SOUND:
1882 /* Those data-block types did not exist in the older version. */
1883 case SOCK_SHADER:
1884 case SOCK_GEOMETRY:
1885 case SOCK_BUNDLE:
1886 case SOCK_CLOSURE:
1887 case SOCK_INT_VECTOR:
1889 break;
1890 }
1891 }
1892
1893 /* Post-reading processing. */
1894 switch (sock->type) {
1895 case SOCK_MENU: {
1896 bNodeSocketValueMenu &default_value = *sock->default_value_typed<bNodeSocketValueMenu>();
1897 /* Clear runtime data. */
1898 default_value.enum_items = nullptr;
1899 default_value.runtime_flag = 0;
1900 break;
1901 }
1902 default:
1903 break;
1904 }
1905}
1906
1908 const bNode *node,
1909 bNodeSocket *sock)
1910{
1911 if (!sock->storage) {
1912 return;
1913 }
1914 if (!node) {
1915 /* Sockets not owned by a node should never have storage data. */
1917 sock->storage = nullptr;
1918 return;
1919 }
1920
1921 /* Sockets storage data seem to have always been written with correct DNA type info (see
1922 * 3bae60d0c9 and 9d91bc38d3). So no need to use the same versioning work-around for old files as
1923 * done for default values. */
1924 switch (node->type_legacy) {
1927 if (sock->storage) {
1928 NodeImageMultiFileSocket *sockdata = static_cast<NodeImageMultiFileSocket *>(
1929 sock->storage);
1930 BKE_image_format_blend_read_data(reader, &sockdata->format);
1931 }
1932 break;
1933 case CMP_NODE_IMAGE:
1934 case CMP_NODE_R_LAYERS:
1935 BLO_read_struct(reader, NodeImageLayer, &sock->storage);
1936 break;
1937 default:
1939 sock->storage = nullptr;
1940 break;
1941 }
1942}
1943
1945{
1946 BLO_read_struct(reader, IDProperty, &sock->prop);
1947 IDP_BlendDataRead(reader, &sock->prop);
1948
1949 BLO_read_struct(reader, bNodeLink, &sock->link);
1950 sock->typeinfo = nullptr;
1951
1953
1955
1957 sock->runtime = MEM_new<bNodeSocketRuntime>(__func__);
1958 sock->runtime->identifier_ustr = UString(sock->identifier);
1959}
1960
1961static void remove_unsupported_sockets(ListBaseT<bNodeSocket> *sockets,
1962 ListBaseT<bNodeLink> *links)
1963{
1964 for (bNodeSocket &sock : sockets->items_mutable()) {
1965 if (is_node_socket_supported(&sock)) {
1966 continue;
1967 }
1968
1969 /* First remove any link pointing to the socket. */
1970 if (links) {
1971 for (bNodeLink &link : links->items_mutable()) {
1972 if (link.fromsock == &sock || link.tosock == &sock) {
1973 BLI_remlink(links, &link);
1974 if (link.tosock) {
1975 link.tosock->link = nullptr;
1976 }
1977 MEM_delete(&link);
1978 }
1979 }
1980 }
1981
1982 BLI_remlink(sockets, &sock);
1983 MEM_delete(sock.runtime);
1984 MEM_delete(&sock);
1985 }
1986}
1987
1989{
1990 if (!node->storage) {
1991 return;
1992 }
1993
1994 /* This may not always find the type for legacy nodes when the idname did not exist yet or it was
1995 * changed. Versioning code will update the nodes with unknown types. */
1996 const bNodeType *ntype = node_type_find(UString(node->idname));
1997
1998 if (ntype && !ntype->storagename.empty()) {
2000 reader, ntype->storagename.c_str(), 1, node->storage);
2001 }
2002 else {
2003 /* Untyped read because we don't know the type yet. */
2004 BLO_read_raw_address(reader, &node->storage);
2005 }
2006
2007 if (ntype && ntype->blend_data_read_storage_content) {
2008 ntype->blend_data_read_storage_content(*ntree, *node, *reader);
2009 return;
2010 }
2011
2012 /* Some nodes don't use the callback above, because they were introduced before there were node
2013 * idnames. Therefore, we can't rely on the idname to lookup the node type. */
2014 switch (node->type_legacy) {
2015 case SH_NODE_CURVE_VEC:
2016 case SH_NODE_CURVE_RGB:
2018 case CMP_NODE_TIME:
2020 case CMP_NODE_CURVE_RGB:
2022 case TEX_NODE_CURVE_RGB:
2023 case TEX_NODE_CURVE_TIME: {
2024 BKE_curvemapping_blend_read(reader, static_cast<CurveMapping *>(node->storage));
2025 break;
2026 }
2027 case SH_NODE_SCRIPT: {
2028 NodeShaderScript *nss = static_cast<NodeShaderScript *>(node->storage);
2029 BLO_read_string(reader, &nss->bytecode);
2030 break;
2031 }
2032 case SH_NODE_TEX_IMAGE: {
2033 NodeTexImage *tex = static_cast<NodeTexImage *>(node->storage);
2034 tex->iuser.scene = nullptr;
2035 break;
2036 }
2038 NodeTexEnvironment *tex = static_cast<NodeTexEnvironment *>(node->storage);
2039 tex->iuser.scene = nullptr;
2040 break;
2041 }
2042 case CMP_NODE_IMAGE:
2043 case CMP_NODE_VIEWER: {
2044 ImageUser *iuser = static_cast<ImageUser *>(node->storage);
2045 iuser->scene = nullptr;
2046 break;
2047 }
2049 case CMP_NODE_CRYPTOMATTE: {
2050 NodeCryptomatte *nc = static_cast<NodeCryptomatte *>(node->storage);
2051 BLO_read_string(reader, &nc->matte_id);
2053 nc->runtime.layers.clear_no_delete();
2054 break;
2055 }
2056 case TEX_NODE_IMAGE: {
2057 ImageUser *iuser = static_cast<ImageUser *>(node->storage);
2058 iuser->scene = nullptr;
2059 break;
2060 }
2061 default:
2062 break;
2063 }
2064}
2065
2072{
2073 static Map<std::string, std::string> idname_map = []() {
2075 map.add("GeometryNodeEvaluateClosure", "NodeEvaluateClosure");
2076 map.add("GeometryNodeClosureInput", "NodeClosureInput");
2077 map.add("GeometryNodeClosureOutput", "NodeClosureOutput");
2078 map.add("GeometryNodeCombineBundle", "NodeCombineBundle");
2079 map.add("GeometryNodeSeparateBundle", "NodeSeparateBundle");
2080 return map;
2081 }();
2082 if (const std::string *new_idname = idname_map.lookup_ptr_as(node.idname)) {
2083 STRNCPY_UTF8(node.idname, new_idname->c_str());
2084 }
2085}
2086
2088{
2089 /* Special case for this pointer, do not rely on regular `lib_link` process here. Avoids needs
2090 * for do_versioning, and ensures coherence of data in any case.
2091 *
2092 * NOTE: Old versions are very often 'broken' here, just fix it silently in these cases.
2093 */
2094 if (BLO_read_fileversion_get(reader) > 300) {
2095 BLI_assert((ntree->id.flag & ID_FLAG_EMBEDDED_DATA) != 0 || owner_id == nullptr);
2096 }
2097 BLI_assert(owner_id == nullptr || owner_id->lib == ntree->id.lib);
2098 if (owner_id != nullptr && (ntree->id.flag & ID_FLAG_EMBEDDED_DATA) == 0) {
2099 /* This is unfortunate, but currently a lot of existing files (including startup ones) have
2100 * missing `ID_FLAG_EMBEDDED_DATA` flag.
2101 *
2102 * NOTE: Using do_version is not a solution here, since this code will be called before any
2103 * do_version takes place. Keeping it here also ensures future (or unknown existing) similar
2104 * bugs won't go easily unnoticed. */
2105 if (BLO_read_fileversion_get(reader) > 300) {
2106 CLOG_WARN(&LOG,
2107 "Fixing root node tree '%s' owned by '%s' missing EMBEDDED tag, please consider "
2108 "re-saving your (startup) file",
2109 ntree->id.name,
2110 owner_id->name);
2111 }
2112 ntree->id.flag |= ID_FLAG_EMBEDDED_DATA;
2113 }
2114 ntree->owner_id = owner_id;
2115
2116 /* NOTE: writing and reading goes in sync, for speed. */
2117 ntree->typeinfo = nullptr;
2118
2119 ntree->runtime = MEM_new<bNodeTreeRuntime>(__func__);
2121
2122 BLO_read_string(reader, &ntree->description);
2123
2124 BLO_read_struct_list(reader, bNode, &ntree->nodes);
2125
2126 for (const auto [i, node] : ntree->nodes.enumerate()) {
2128 node.runtime = MEM_new<bNodeRuntime>(__func__);
2129 node.typeinfo = nullptr;
2130 node.runtime->index_in_tree = i;
2131
2132 /* Create the `nodes_by_id` cache eagerly so it can be expected to be valid. Because
2133 * we create it here we also have to check for zero identifiers from previous versions. */
2134 if (node.identifier == 0 || ntree->runtime->nodes_by_id.contains_as(node.identifier)) {
2135 node_unique_id(*ntree, node);
2136 }
2137 else {
2138 ntree->runtime->nodes_by_id.add_new(&node);
2139 }
2140
2141 BLO_read_struct_list(reader, bNodeSocket, &node.inputs);
2142 BLO_read_struct_list(reader, bNodeSocket, &node.outputs);
2143 BLO_read_array_and_validate_size(reader, &node.panel_states_array, &node.num_panel_states);
2144
2145 BLO_read_struct(reader, IDProperty, &node.prop);
2146 IDP_BlendDataRead(reader, &node.prop);
2147 BLO_read_struct(reader, IDProperty, &node.system_properties);
2148 IDP_BlendDataRead(reader, &node.system_properties);
2149
2150 node_blend_read_data_storage(reader, ntree, &node);
2151 }
2152 BLO_read_struct_list(reader, bNodeLink, &ntree->links);
2153 BLI_assert(ntree->all_nodes().size() == ntree->nodes.count());
2154
2155 /* and we connect the rest */
2156 for (bNode &node : ntree->nodes) {
2157 BLO_read_struct(reader, bNode, &node.parent);
2158
2159 for (bNodeSocket &sock : node.inputs.items_mutable()) {
2160 direct_link_node_socket(reader, &node, &sock);
2161 }
2162 for (bNodeSocket &sock : node.outputs.items_mutable()) {
2163 direct_link_node_socket(reader, &node, &sock);
2164 }
2165 }
2166
2167 /* Read legacy interface socket lists for versioning. */
2170 for (bNodeSocket &sock : ntree->inputs_legacy.items_mutable()) {
2171 direct_link_node_socket(reader, nullptr, &sock);
2172 }
2173 for (bNodeSocket &sock : ntree->outputs_legacy.items_mutable()) {
2174 direct_link_node_socket(reader, nullptr, &sock);
2175 }
2176
2177 ntree->tree_interface.read_data(reader);
2178
2179 for (bNodeLink &link : ntree->links) {
2180 BLO_read_struct(reader, bNode, &link.fromnode);
2181 BLO_read_struct(reader, bNode, &link.tonode);
2182 BLO_read_struct(reader, bNodeSocket, &link.fromsock);
2183 BLO_read_struct(reader, bNodeSocket, &link.tosock);
2184 }
2185
2186 for (bNode &node : ntree->nodes) {
2187 remove_unsupported_sockets(&node.inputs, &ntree->links);
2188 remove_unsupported_sockets(&node.outputs, &ntree->links);
2189 }
2190 remove_unsupported_sockets(&ntree->inputs_legacy, nullptr);
2192
2194 if (ntree->geometry_node_asset_traits) {
2196 }
2198
2200
2201 BLO_read_struct(reader, PreviewImage, &ntree->preview);
2202 BKE_previewimg_blend_read(reader, ntree->preview);
2203
2204 /* type verification is in lib-link */
2205}
2206
2208{
2209 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
2210 node_tree_blend_read_data(reader, nullptr, ntree);
2211}
2212
2214{
2215 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(id);
2216
2217 /* Set `node->typeinfo` pointers. This is done in lib linking, after the
2218 * first versioning that can change types still without functions that
2219 * update the `typeinfo` pointers. Versioning after lib linking needs
2220 * these to be valid. */
2221 node_tree_set_type(*ntree);
2222
2223 /* For nodes with static socket layout, add/remove sockets as needed
2224 * to match the static layout. */
2225 if (!BLO_read_lib_is_undo(reader)) {
2226 for (bNode &node : ntree->nodes) {
2227 /* Don't update nodes whose declaration may depend on other IDs which may not be fully linked
2228 * and versioned yet. */
2229 const bool is_context_dependent = node.typeinfo->static_declaration &&
2230 node.typeinfo->static_declaration->is_context_dependent;
2231 const bool references_another_id = node.id != nullptr;
2232 if (!(is_context_dependent && references_another_id)) {
2233 node_verify_sockets(reader->main, ntree, &node, false);
2234 }
2235 }
2236 }
2237}
2238
2239static std::unique_ptr<IDProperty, idprop::IDPropertyDeleter> create_socket_meta_data_properties(
2240 const bNodeTreeInterfaceSocket &socket, const bool create_default_value_properties)
2241{
2242 const bNodeSocketType *base_typeinfo = node_socket_type_find(socket.socket_type);
2243
2244 auto socket_prop = idprop::create_group(socket.identifier);
2245 IDP_AddToGroup(socket_prop.get(), idprop::create("name", socket.name()).release());
2246 IDP_AddToGroup(socket_prop.get(), idprop::create("type", base_typeinfo->type).release());
2247 IDP_AddToGroup(socket_prop.get(), idprop::create("description", socket.description()).release());
2248 switch (base_typeinfo->type) {
2249 case SOCK_FLOAT: {
2251 IDP_AddToGroup(socket_prop.get(), idprop::create("subtype", value.subtype).release());
2252 IDP_AddToGroup(socket_prop.get(), idprop::create("min", value.min).release());
2253 IDP_AddToGroup(socket_prop.get(), idprop::create("max", value.max).release());
2254 if (create_default_value_properties) {
2255 IDP_AddToGroup(socket_prop.get(), idprop::create("default_value", value.value).release());
2256 if (socket.default_attribute_name) {
2258 socket_prop.get(),
2259 idprop::create("default_attribute_name", socket.default_attribute_name).release());
2260 }
2261 }
2262 break;
2263 }
2264 case SOCK_VECTOR: {
2266 IDP_AddToGroup(socket_prop.get(), idprop::create("subtype", value.subtype).release());
2267 if (value.dimensions != 3) {
2268 IDP_AddToGroup(socket_prop.get(),
2269 idprop::create("dimensions", value.dimensions).release());
2270 }
2271 IDP_AddToGroup(socket_prop.get(), idprop::create("min", value.min).release());
2272 IDP_AddToGroup(socket_prop.get(), idprop::create("max", value.max).release());
2273 if (create_default_value_properties) {
2275 socket_prop.get(),
2276 idprop::create("default_value", Span(value.value, value.dimensions)).release());
2277 if (socket.default_attribute_name) {
2279 socket_prop.get(),
2280 idprop::create("default_attribute_name", socket.default_attribute_name).release());
2281 }
2282 }
2283 break;
2284 }
2285 case SOCK_INT_VECTOR: {
2287 IDP_AddToGroup(socket_prop.get(), idprop::create("subtype", value.subtype).release());
2288 if (value.dimensions != 3) {
2289 IDP_AddToGroup(socket_prop.get(),
2290 idprop::create("dimensions", value.dimensions).release());
2291 }
2292 IDP_AddToGroup(socket_prop.get(), idprop::create("min", value.min).release());
2293 IDP_AddToGroup(socket_prop.get(), idprop::create("max", value.max).release());
2294 if (create_default_value_properties) {
2296 socket_prop.get(),
2297 idprop::create("default_value", Span(value.value, value.dimensions)).release());
2298 if (socket.default_attribute_name) {
2300 socket_prop.get(),
2301 idprop::create("default_attribute_name", socket.default_attribute_name).release());
2302 }
2303 }
2304 break;
2305 }
2306 case SOCK_RGBA: {
2308 if (create_default_value_properties) {
2309 IDP_AddToGroup(socket_prop.get(),
2310 idprop::create("default_value", Span(value.value, 4)).release());
2311 if (socket.default_attribute_name) {
2313 socket_prop.get(),
2314 idprop::create("default_attribute_name", socket.default_attribute_name).release());
2315 }
2316 }
2317 break;
2318 }
2319 case SOCK_BOOLEAN: {
2321 if (create_default_value_properties) {
2322 IDP_AddToGroup(socket_prop.get(),
2323 idprop::create_bool("default_value", value.value).release());
2324 if (socket.default_attribute_name) {
2326 socket_prop.get(),
2327 idprop::create("default_attribute_name", socket.default_attribute_name).release());
2328 }
2329 }
2330 break;
2331 }
2332 case SOCK_ROTATION: {
2334 if (create_default_value_properties) {
2335 const float3 default_value = float3(math::EulerXYZ(float3(value.value_euler)));
2336 IDP_AddToGroup(socket_prop.get(),
2337 idprop::create("default_value", Span(&default_value.x, 3)).release());
2338 if (socket.default_attribute_name) {
2340 socket_prop.get(),
2341 idprop::create("default_attribute_name", socket.default_attribute_name).release());
2342 }
2343 }
2344 break;
2345 }
2346 case SOCK_INT: {
2348 IDP_AddToGroup(socket_prop.get(), idprop::create("subtype", value.subtype).release());
2349 IDP_AddToGroup(socket_prop.get(), idprop::create("min", value.min).release());
2350 IDP_AddToGroup(socket_prop.get(), idprop::create("max", value.max).release());
2351 if (create_default_value_properties) {
2352 IDP_AddToGroup(socket_prop.get(), idprop::create("default_value", value.value).release());
2353 if (socket.default_attribute_name) {
2355 socket_prop.get(),
2356 idprop::create("default_attribute_name", socket.default_attribute_name).release());
2357 }
2358 }
2359 break;
2360 }
2361 case SOCK_STRING: {
2363 IDP_AddToGroup(socket_prop.get(), idprop::create("subtype", value.subtype).release());
2364 if (create_default_value_properties) {
2365 IDP_AddToGroup(socket_prop.get(), idprop::create("default_value", value.value).release());
2366 }
2367 break;
2368 }
2369 case SOCK_MENU: {
2371 if (value.enum_items) {
2372 if (create_default_value_properties) {
2373 if (std::ranges::any_of(
2374 value.enum_items->items,
2375 [&](const RuntimeNodeEnumItem &item) { return item.identifier == value.value; }))
2376 {
2377 /* Only add the default value property if it's contained in the enum items. */
2378 IDP_AddToGroup(socket_prop.get(),
2379 idprop::create("default_value", value.value).release());
2380 }
2381 }
2382 auto items = idprop::create_group("items");
2383 for (const RuntimeNodeEnumItem &enum_item : value.enum_items->items) {
2384 auto item = idprop::create_group(enum_item.name);
2385 IDP_AddToGroup(item.get(), idprop::create("value", enum_item.identifier).release());
2386 IDP_AddToGroup(item.get(),
2387 idprop::create("description", enum_item.description).release());
2388 IDP_AddToGroup(items.get(), item.release());
2389 }
2390 IDP_AddToGroup(socket_prop.get(), items.release());
2391 }
2392 break;
2393 }
2394 case SOCK_SHADER:
2395 case SOCK_MATRIX:
2396 case SOCK_OBJECT:
2397 case SOCK_IMAGE:
2398 case SOCK_GEOMETRY:
2399 case SOCK_COLLECTION:
2400 case SOCK_TEXTURE:
2401 case SOCK_MATERIAL:
2402 case SOCK_BUNDLE:
2403 case SOCK_CLOSURE:
2404 case SOCK_CUSTOM:
2405 case SOCK_FONT:
2406 case SOCK_SCENE:
2407 case SOCK_TEXT_ID:
2408 case SOCK_MASK:
2409 case SOCK_SOUND:
2410 break;
2411 }
2412 return socket_prop;
2413}
2414
2416{
2417 auto properties = idprop::create_group("properties");
2418 auto inputs = idprop::create_group("inputs");
2419 node_tree.ensure_interface_cache();
2420 for (const bNodeTreeInterfaceSocket *socket : node_tree.interface_inputs()) {
2421 auto input = create_socket_meta_data_properties(*socket, true);
2422 IDP_AddToGroup(inputs.get(), input.release());
2423 }
2424 IDP_AddToGroup(properties.get(), inputs.release());
2425
2426 auto panels = idprop::create_group("panels");
2427 for (const bNodeTreeInterfaceItem *item : node_tree.interface_items()) {
2428 if (item->item_type != NodeTreeInterfaceItemType::Panel) {
2429 continue;
2430 }
2431 const auto &panel = *reinterpret_cast<const bNodeTreeInterfacePanel *>(item);
2432 std::string open_identifier = fmt::format("open_{}", panel.identifier);
2433 auto panel_props = idprop::create_group(open_identifier);
2435 panels.get(),
2436 idprop::create_bool(open_identifier, panel.flag & NODE_INTERFACE_PANEL_DEFAULT_CLOSED)
2437 .release());
2438 }
2439 IDP_AddToGroup(properties.get(), panels.release());
2440
2441 /* NOTE: The `output` group is kept for compatibility. This should be replaced by
2442 * `output_sockets` in Blender 6.0 (next breaking release). */
2443 auto outputs = idprop::create_group("outputs");
2444 for (const bNodeTreeInterfaceSocket *socket : node_tree.interface_outputs()) {
2445 auto *prop = idprop::create(socket->name(), socket->socket_type).release();
2446 if (!IDP_AddToGroup(outputs.get(), prop)) {
2447 IDP_FreeProperty(prop);
2448 }
2449 }
2450 IDP_AddToGroup(properties.get(), outputs.release());
2451
2452 auto output_sockets = idprop::create_group("output_sockets");
2453 for (const bNodeTreeInterfaceSocket *socket : node_tree.interface_outputs()) {
2454 auto output = create_socket_meta_data_properties(*socket, false);
2455 IDP_AddToGroup(output_sockets.get(), output.release());
2456 }
2457 IDP_AddToGroup(properties.get(), output_sockets.release());
2458
2459 return properties.release();
2460}
2461
2463{
2464 AssetMetaData *asset_data = node_tree.id.asset_data;
2465 if (!asset_data) {
2466 return;
2467 }
2468
2469 BKE_asset_metadata_idprop_ensure(asset_data, idprop::create("type", node_tree.type).release());
2471 if (node_tree.geometry_node_asset_traits) {
2472 auto property = idprop::create("geometry_node_asset_traits_flag",
2473 node_tree.geometry_node_asset_traits->flag);
2474 BKE_asset_metadata_idprop_ensure(asset_data, property.release());
2476 auto property = idprop::create(
2477 "node_tool_idname",
2479 BKE_asset_metadata_idprop_ensure(asset_data, property.release());
2480 }
2481 }
2482 if (node_tree.compositor_node_asset_traits) {
2483 auto property = idprop::create("compositor_node_asset_traits_flag",
2485 BKE_asset_metadata_idprop_ensure(asset_data, property.release());
2486 }
2487}
2488
2489static void node_tree_asset_pre_save(void *asset_ptr, AssetMetaData * /*asset_data*/)
2490{
2491 bNodeTree &ntree = *static_cast<bNodeTree *>(asset_ptr);
2493}
2494
2495static void node_tree_asset_on_mark_asset(void *asset_ptr, AssetMetaData *asset_data)
2496{
2497 bNodeTree &ntree = *static_cast<bNodeTree *>(asset_ptr);
2499
2500 /* Copy node tree description to asset description so that the user does not have to write it
2501 * again. */
2502 if (!asset_data->description) {
2503 asset_data->description = BLI_strdup_null(ntree.description);
2504 }
2505}
2506
2507static void node_tree_asset_on_clear_asset(void *asset_ptr, AssetMetaData *asset_data)
2508{
2509 bNodeTree &ntree = *static_cast<bNodeTree *>(asset_ptr);
2510
2511 /* Copy asset description to node tree description so that it is not lost when the asset data is
2512 * removed. */
2513 if (asset_data->description) {
2514 MEM_SAFE_DELETE(ntree.description);
2515 ntree.description = BLI_strdup_null(asset_data->description);
2516 }
2517}
2518
2519} // namespace bke
2520
2522 /*pre_save_fn*/ bke::node_tree_asset_pre_save,
2523 /*on_mark_asset_fn*/ bke::node_tree_asset_on_mark_asset,
2524 /*on_clear_asset_fn*/ bke::node_tree_asset_on_clear_asset,
2525};
2526
2528 .id_code = bNodeTree::id_type,
2529 .id_filter = FILTER_ID_NT,
2530 /* IDProps of nodes, and #bNode.id, can use any type of ID. */
2531 .dependencies_id_types = FILTER_ID_ALL,
2532 .main_listbase_index = INDEX_ID_NT,
2533 .struct_size = sizeof(bNodeTree),
2534 .name = "NodeTree",
2535 .name_plural = N_("node_groups"),
2536 .translation_context = BLT_I18NCONTEXT_ID_NODETREE,
2538 .asset_type_info = &AssetType_NT,
2539
2540 .init_data = bke::ntree_init_data,
2541 .copy_data = bke::ntree_copy_data,
2542 .free_data = bke::ntree_free_data,
2543 .make_local = nullptr,
2544 .foreach_id = bke::node_foreach_id,
2545 .foreach_cache = nullptr,
2546 .foreach_path = bke::node_foreach_path,
2547 .foreach_working_space_color = bke::node_foreach_working_space_color,
2548 .foreach_asset_weak_reference = nullptr,
2549 .owner_pointer_get = bke::node_owner_pointer_get,
2550
2551 .blend_write = bke::ntree_blend_write,
2552 .blend_read_data = bke::ntree_blend_read_data,
2553 .blend_read_after_liblink = bke::ntree_blend_read_after_liblink,
2554
2555 .blend_read_undo_preserve = nullptr,
2556
2557 .lib_override_apply_post = nullptr,
2558};
2559
2560namespace bke {
2561
2563{
2564 if (ntype->declare) {
2565 node_verify_sockets(nullptr, ntree, node, true);
2566 return;
2567 }
2568 bNodeSocketTemplate *sockdef;
2569
2570 if (ntype->inputs) {
2571 sockdef = ntype->inputs;
2572 while (sockdef->type != -1) {
2573 node_add_socket_from_template(ntree, node, sockdef, SOCK_IN);
2574 sockdef++;
2575 }
2576 }
2577 if (ntype->outputs) {
2578 sockdef = ntype->outputs;
2579 while (sockdef->type != -1) {
2581 sockdef++;
2582 }
2583 }
2584}
2585
2586/* NOTE: This function is called to initialize node data based on the type.
2587 * The #bNodeType may not be registered at creation time of the node,
2588 * so this can be delayed until the node type gets registered.
2589 */
2590static void node_init(const bContext *C, bNodeTree *ntree, bNode *node)
2591{
2592 BLI_assert(ntree != nullptr);
2593 bNodeType *ntype = node->typeinfo;
2594 if (ntype == &NodeTypeUndefined) {
2595 return;
2596 }
2597
2598 /* only do this once */
2599 if (node->flag & NODE_INIT) {
2600 return;
2601 }
2602
2603 node->flag = NODE_SELECT | NODE_OPTIONS | (ntype->flag & ~NODE_PREVIEW);
2604 node->width = ntype->default_width;
2605 node->height = ntype->height;
2606 node->color[0] = node->color[1] = node->color[2] = 0.608; /* default theme color */
2607 /* initialize the node name with the node label.
2608 * NOTE: do this after the initfunc so nodes get their data set which may be used in naming
2609 * (node groups for example) */
2610 /* XXX Do not use nodeLabel() here, it returns translated content for UI,
2611 * which should *only* be used in UI, *never* in data...
2612 * Data have their own translation option!
2613 * This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler
2614 * than adding "do_translate" flags to this func (and labelfunc() as well). */
2615 DATA_(ntype->ui_name).copy_utf8_truncated(node->name);
2616 node_unique_name(*ntree, *node);
2617
2618 /* Generally sockets should be added after the initialization, because the set of sockets might
2619 * depend on node properties. */
2620 const bool add_sockets_before_init = node->type_legacy == CMP_NODE_R_LAYERS;
2621 if (add_sockets_before_init) {
2622 node_add_sockets_from_type(ntree, node, ntype);
2623 }
2624
2625 if (ntype->initfunc != nullptr) {
2626 ntype->initfunc(ntree, node);
2627 }
2628
2629 if (ntype->initfunc_api && C) {
2630 PointerRNA ptr = RNA_pointer_create_discrete(&ntree->id, RNA_Node, node);
2631 ntype->initfunc_api(C, &ptr);
2632 }
2633
2634 if (!add_sockets_before_init) {
2635 node_add_sockets_from_type(ntree, node, ntype);
2636 }
2637
2638 if (node->id) {
2639 id_us_plus(node->id);
2640 }
2641
2642 node->flag |= NODE_INIT;
2643}
2644
2645static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo)
2646{
2647 if (typeinfo) {
2648 ntree->typeinfo = typeinfo;
2649 }
2650 else {
2652 }
2653
2654 /* Deprecated integer type. */
2655 ntree->type = ntree->typeinfo->type;
2657}
2658
2659static void node_set_typeinfo(const bContext *C,
2660 bNodeTree *ntree,
2661 bNode *node,
2662 bNodeType *typeinfo)
2663{
2664 /* for nodes saved in older versions storage can get lost, make undefined then */
2665 if (node->flag & NODE_INIT) {
2666 if (typeinfo && typeinfo->storagename[0] && !node->storage) {
2667 typeinfo = nullptr;
2668 }
2669 }
2670
2671 if (typeinfo) {
2672 node->typeinfo = typeinfo;
2673
2674 /* deprecated integer type */
2675 node->type_legacy = typeinfo->type_legacy;
2676
2677 /* initialize the node if necessary */
2678 node_init(C, ntree, node);
2679 }
2680 else {
2681 node->typeinfo = &NodeTypeUndefined;
2682 }
2684}
2685
2686/* WARNING: default_value must either be null or match the typeinfo at this point.
2687 * This function is called both for initializing new sockets and after loading files.
2688 */
2690 bNodeSocket *sock,
2691 bNodeSocketType *typeinfo)
2692{
2693 if (typeinfo) {
2694 sock->typeinfo = typeinfo;
2695
2696 /* deprecated integer type */
2697 sock->type = typeinfo->type;
2698
2699 if (sock->default_value == nullptr) {
2700 /* initialize the default_value pointer used by standard socket types */
2701 sock->default_value = socket_value_new(sock->type, sock->typeinfo->subtype);
2702 }
2703 }
2704 else {
2706 }
2708}
2709
2710/* Set specific typeinfo pointers in all node trees on register/unregister */
2711static void update_typeinfo(Main *bmain,
2712 bNodeTreeType *treetype,
2713 bNodeType *nodetype,
2714 bNodeSocketType *socktype,
2715 const bool unregister)
2716{
2717 if (!bmain) {
2718 return;
2719 }
2720
2721 FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
2722 if (treetype && ntree->idname == treetype->idname) {
2723 ntree_set_typeinfo(ntree, unregister ? nullptr : treetype);
2724 }
2725
2726 /* initialize nodes */
2727 for (bNode *node : ntree->all_nodes()) {
2728 if (nodetype && node->idname == nodetype->idname) {
2729 node_set_typeinfo(nullptr, ntree, node, unregister ? nullptr : nodetype);
2730 }
2731
2732 /* initialize node sockets */
2733 for (bNodeSocket &sock : node->inputs) {
2734 if (socktype && sock.idname == socktype->idname) {
2735 node_socket_set_typeinfo(ntree, &sock, unregister ? nullptr : socktype);
2736 }
2737 }
2738 for (bNodeSocket &sock : node->outputs) {
2739 if (socktype && sock.idname == socktype->idname) {
2740 node_socket_set_typeinfo(ntree, &sock, unregister ? nullptr : socktype);
2741 }
2742 }
2743 }
2744 }
2746}
2747
2749{
2751
2752 for (bNode *node : ntree.all_nodes()) {
2753 /* Set socket typeinfo first because node initialization may rely on socket typeinfo for
2754 * generating declarations. */
2755 for (bNodeSocket &sock : node->inputs) {
2757 }
2758 for (bNodeSocket &sock : node->outputs) {
2760 }
2761
2762 node_set_typeinfo(nullptr, &ntree, node, node_type_find(UString(node->idname)));
2763 }
2764}
2765
2766template<typename T> struct NodeStructIDNameGetter {
2767 UString operator()(const T *value) const
2768 {
2769 return value->idname;
2770 }
2771};
2772
2778
2779static auto &get_node_type_map()
2780{
2782 return map;
2783}
2784
2786{
2787 static Map<UString, UString> map;
2788 return map;
2789}
2790
2796
2798{
2799 bNodeTreeType *const *value = get_node_tree_type_map().lookup_key_ptr_as(UString(idname));
2800 if (!value) {
2801 return nullptr;
2802 }
2803 return *value;
2804}
2805
2807{
2808 for (bNodeTreeType *type : get_node_tree_type_map()) {
2809 if (type->type == tree_type) {
2810 return type;
2811 }
2812 }
2813 return nullptr;
2814}
2815
2817{
2818 static ResourceScope scope;
2819 scope.add_destruct_call([tree_type]() { MEM_delete(tree_type); });
2820}
2821
2823{
2824 static ResourceScope scope;
2825 scope.add_destruct_call([ntype]() {
2826 /* May be null if the type is statically allocated. */
2827 if (ntype->free_self) {
2828 ntype->free_self(ntype);
2829 }
2830 });
2831}
2832
2834{
2835 static ResourceScope scope;
2836 scope.add_destruct_call([stype]() {
2837 /* May be null if the type is statically allocated. */
2838 if (stype->free_self) {
2839 stype->free_self(stype);
2840 }
2841 });
2842}
2843
2845{
2846 get_node_tree_type_map().add(&nt);
2847 /* XXX pass Main to register function? */
2848 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
2849 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
2850 update_typeinfo(G_MAIN, &nt, nullptr, nullptr, false);
2851}
2852
2853static void ntree_free_type(void *treetype_v)
2854{
2855 bNodeTreeType *treetype = static_cast<bNodeTreeType *>(treetype_v);
2856 /* XXX pass Main to unregister function? */
2857 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
2858 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
2859 update_typeinfo(G_MAIN, treetype, nullptr, nullptr, true);
2860
2861 /* Defer freeing the tree type, because it may still be referenced by trees in depsgraph
2862 * copies. We can't just remove these tree types, because the depsgraph may exist completely
2863 * separately from original data. */
2864 defer_free_tree_type(treetype);
2865}
2866
2868{
2869 get_node_tree_type_map().remove(const_cast<bNodeTreeType *>(&nt));
2870 ntree_free_type(const_cast<bNodeTreeType *>(&nt));
2871}
2872
2874{
2875 return (ntree.typeinfo != &NodeTreeTypeUndefined);
2876}
2877
2882
2884{
2885 bNodeType *const *value = get_node_type_map().lookup_key_ptr_as(idname);
2886 if (!value) {
2887 return nullptr;
2888 }
2889 return *value;
2890}
2891
2893{
2894 const UString *idname = get_node_type_alias_map().lookup_ptr_as(alias);
2895 if (!idname) {
2896 return alias;
2897 }
2898 return *idname;
2899}
2900
2901static void node_free_type(void *nodetype_v)
2902{
2903 bNodeType *nodetype = static_cast<bNodeType *>(nodetype_v);
2904 /* XXX pass Main to unregister function? */
2905 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
2906 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
2907 update_typeinfo(G_MAIN, nullptr, nodetype, nullptr, true);
2908
2909 /* Setting this to null is necessary for the case of static node types. When running tests,
2910 * they may be registered and unregistered multiple times. */
2911 delete nodetype->static_declaration;
2912 nodetype->static_declaration = nullptr;
2913
2914 /* Defer freeing the node type, because it may still be referenced by nodes in depsgraph
2915 * copies. We can't just remove these node types, because the depsgraph may exist completely
2916 * separate from original data. */
2917 defer_free_node_type(nodetype);
2918}
2919
2921{
2922 /* debug only: basic verification of registered types */
2923 BLI_assert(!nt.idname.is_empty());
2924 BLI_assert(nt.poll != nullptr);
2925
2926 RNA_def_struct_ui_text(nt.rna_ext.srna, nt.ui_name.c_str(), nt.ui_description.c_str());
2927
2928 if (!nt.enum_name_legacy) {
2929 /* For new nodes, use the idname as a unique identifier. */
2930 nt.enum_name_legacy = nt.idname.c_str();
2931 }
2932
2933 if (nt.declare) {
2935 nodes::build_node_declaration(nt, *nt.static_declaration, nullptr, nullptr);
2936 }
2937
2938 get_node_type_map().add_new(&nt);
2939 /* XXX pass Main to register function? */
2940 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
2941 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
2942 update_typeinfo(G_MAIN, nullptr, &nt, nullptr, false);
2943}
2944
2946{
2947 get_node_type_map().remove(&nt);
2948 node_free_type(&nt);
2949}
2950
2952{
2953 return get_node_type_map().as_span();
2954}
2955
2957{
2958 get_node_type_alias_map().add_new(alias, nt.idname);
2959}
2960
2965
2967{
2968 bNodeSocketType *const *value = get_socket_type_map().lookup_key_ptr_as(UString(idname));
2969 if (!value) {
2970 return nullptr;
2971 }
2972 return *value;
2973}
2974
2975bNodeSocketType *node_socket_type_find_static(const int type, const int subtype)
2976{
2977 const std::optional<StringRefNull> idname = node_static_socket_type(type, subtype);
2978 if (!idname) {
2979 return nullptr;
2980 }
2981 return node_socket_type_find(*idname);
2982}
2983
2984static void node_free_socket_type(void *socktype_v)
2985{
2986 bNodeSocketType *socktype = static_cast<bNodeSocketType *>(socktype_v);
2987 /* XXX pass Main to unregister function? */
2988 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
2989 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
2990 update_typeinfo(G_MAIN, nullptr, nullptr, socktype, true);
2991
2992 /* Defer freeing the socket type, because it may still be referenced by nodes in depsgraph
2993 * copies. We can't just remove these socket types, because the depsgraph may exist completely
2994 * separate from original data. */
2995 defer_free_socket_type(socktype);
2996}
2997
2999{
3000 get_socket_type_map().add(&st);
3001 /* XXX pass Main to register function? */
3002 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
3003 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
3004 update_typeinfo(G_MAIN, nullptr, nullptr, &st, false);
3005}
3006
3012
3014{
3015 return (sock.typeinfo != &NodeSocketTypeUndefined);
3016}
3017
3019{
3020 /* Use socket type name as a fallback if label is undefined. */
3021 if (stype.label[0] == '\0') {
3022 return RNA_struct_ui_name(stype.ext_socket.srna);
3023 }
3024 return stype.label;
3025}
3026
3028{
3029 const char *name;
3030 if (RNA_enum_name(rna_enum_property_subtype_items, subtype, &name)) {
3031 return name;
3032 }
3033 return "";
3034}
3035
3037{
3038 ListBaseT<bNodeSocket> *sockets = (in_out == SOCK_IN) ? &node.inputs : &node.outputs;
3039 for (bNodeSocket &sock : *sockets) {
3040 if (sock.identifier_ustr() == identifier) {
3041 return &sock;
3042 }
3043 }
3044 return nullptr;
3045}
3046
3048 const eNodeSocketInOut in_out,
3049 const UString identifier)
3050{
3051 /* Reuse the implementation of the mutable accessor. */
3052 return node_find_socket(*const_cast<bNode *>(&node), in_out, identifier);
3053}
3054
3056 const eNodeSocketInOut in_out,
3057 const StringRef name)
3058{
3059 ListBaseT<bNodeSocket> *sockets = (in_out == SOCK_IN) ? &node.inputs : &node.outputs;
3060 for (bNodeSocket &socket : *sockets) {
3061 if (socket.is_available() && socket.name == name) {
3062 return &socket;
3063 }
3064 }
3065 return nullptr;
3066}
3067
3072
3077
3079 bNode * /*node*/,
3080 const eNodeSocketInOut in_out,
3081 ListBaseT<bNodeSocket> *lb,
3082 const StringRefNull idname,
3083 const StringRefNull identifier,
3084 const StringRefNull name)
3085{
3086 char auto_identifier[MAX_NAME];
3087
3088 if (identifier[0] != '\0') {
3089 /* use explicit identifier */
3090 identifier.copy_utf8_truncated(auto_identifier);
3091 }
3092 else {
3093 /* if no explicit identifier is given, assign a unique identifier based on the name */
3094 name.copy_utf8_truncated(auto_identifier);
3095 }
3096 /* Make the identifier unique. */
3098 [&](const StringRef check_name) {
3099 for (const bNodeSocket &sock : *lb) {
3100 if (sock.identifier == check_name) {
3101 return true;
3102 }
3103 }
3104 return false;
3105 },
3106 "socket",
3107 '_',
3108 auto_identifier,
3109 sizeof(auto_identifier));
3110
3111 bNodeSocket *sock = MEM_new<bNodeSocket>(__func__);
3112 sock->runtime = MEM_new<bNodeSocketRuntime>(__func__);
3113 sock->in_out = in_out;
3114
3115 STRNCPY_UTF8(sock->identifier, auto_identifier);
3116 sock->runtime->identifier_ustr = UString(sock->identifier);
3117 sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
3118
3119 name.copy_utf8_truncated(sock->name);
3120 sock->storage = nullptr;
3121 sock->flag |= SOCK_COLLAPSED;
3122 sock->type = SOCK_CUSTOM; /* int type undefined by default */
3123
3124 idname.copy_utf8_truncated(sock->idname);
3125 node_socket_set_typeinfo(ntree, sock, node_socket_type_find(idname));
3126
3127 return sock;
3128}
3129
3131{
3132 ID *id = nullptr;
3133 socket_data_to_static_type(type, [&]<typename T>() {
3134 if constexpr (is_same_any_v<T,
3145 {
3146 id = id_cast<ID *>(static_cast<T *>(data)->value);
3147 }
3148 });
3149 return id;
3150}
3151
3153{
3154 if (data == nullptr) {
3155 return;
3156 }
3158}
3159
3161{
3162 if (data == nullptr) {
3163 return;
3164 }
3166}
3167
3168template<typename T> static void socket_value_init_impl(T & /*data*/, const int /*subtype*/) {}
3169
3170template<> void socket_value_init_impl(bNodeSocketValueFloat &data, const int subtype)
3171{
3172 data.subtype = subtype;
3173 data.value = 0.0f;
3174 data.min = -FLT_MAX;
3175 data.max = FLT_MAX;
3176}
3177template<> void socket_value_init_impl(bNodeSocketValueInt &data, const int subtype)
3178{
3179 data.subtype = subtype;
3180 data.value = 0;
3181 data.min = INT_MIN;
3182 data.max = INT_MAX;
3183}
3184template<> void socket_value_init_impl(bNodeSocketValueBoolean &data, const int /*subtype*/)
3185{
3186 data.value = false;
3187}
3188template<> void socket_value_init_impl(bNodeSocketValueRotation & /*data*/, const int /*subtype*/)
3189{
3190}
3191template<> void socket_value_init_impl(bNodeSocketValueVector &data, const int subtype)
3192{
3193 static float default_value[] = {0.0f, 0.0f, 0.0f};
3194 data.subtype = subtype;
3195 data.dimensions = 3;
3196 copy_v3_v3(data.value, default_value);
3197 data.min = -FLT_MAX;
3198 data.max = FLT_MAX;
3199}
3200template<> void socket_value_init_impl(bNodeSocketValueIntVector &data, const int subtype)
3201{
3202 data.subtype = subtype;
3203 data.dimensions = 3;
3204 zero_v3_int(data.value);
3205 data.min = INT_MIN;
3206 data.max = INT_MAX;
3207}
3208template<> void socket_value_init_impl(bNodeSocketValueRGBA &data, const int /*subtype*/)
3209{
3210 static float default_value[] = {0.0f, 0.0f, 0.0f, 1.0f};
3211 copy_v4_v4(data.value, default_value);
3212}
3213template<> void socket_value_init_impl(bNodeSocketValueString &data, const int subtype)
3214{
3215 data.subtype = subtype;
3216 data.value[0] = '\0';
3217}
3218template<> void socket_value_init_impl(bNodeSocketValueObject &data, const int /*subtype*/)
3219{
3220 data.value = nullptr;
3221}
3222template<> void socket_value_init_impl(bNodeSocketValueImage &data, const int /*subtype*/)
3223{
3224 data.value = nullptr;
3225}
3226template<> void socket_value_init_impl(bNodeSocketValueCollection &data, const int /*subtype*/)
3227{
3228 data.value = nullptr;
3229}
3230template<> void socket_value_init_impl(bNodeSocketValueTexture &data, const int /*subtype*/)
3231{
3232 data.value = nullptr;
3233}
3234template<> void socket_value_init_impl(bNodeSocketValueMaterial &data, const int /*subtype*/)
3235{
3236 data.value = nullptr;
3237}
3238template<> void socket_value_init_impl(bNodeSocketValueFont &data, const int /*subtype*/)
3239{
3240 data.value = nullptr;
3241}
3242template<> void socket_value_init_impl(bNodeSocketValueScene &data, const int /*subtype*/)
3243{
3244 data.value = nullptr;
3245}
3246template<> void socket_value_init_impl(bNodeSocketValueText &data, const int /*subtype*/)
3247{
3248 data.value = nullptr;
3249}
3250template<> void socket_value_init_impl(bNodeSocketValueMask &data, const int /*subtype*/)
3251{
3252 data.value = nullptr;
3253}
3254template<> void socket_value_init_impl(bNodeSocketValueSound &data, const int /*subtype*/)
3255{
3256 data.value = nullptr;
3257}
3258template<> void socket_value_init_impl(bNodeSocketValueMenu &data, const int /*subtype*/)
3259{
3260 data.value = -1;
3261 data.enum_items = nullptr;
3262 data.runtime_flag = 0;
3263}
3264
3265void socket_value_init(const eNodeSocketDatatype type, void *data, const int subtype)
3266{
3267 if (data == nullptr) {
3268 return;
3269 }
3271 type, [&]<typename T>() { socket_value_init_impl(*static_cast<T *>(data), subtype); });
3272}
3273
3274void *socket_value_new(const eNodeSocketDatatype type, const int subtype)
3275{
3276 void *result = nullptr;
3277 socket_data_to_static_type(type, [&]<typename T>() {
3278 T *data = MEM_new<T>(__func__);
3279 socket_value_init_impl(*data, subtype);
3280 result = data;
3281 });
3282 return result;
3283}
3284
3285void *socket_value_copy(const eNodeSocketDatatype type, const void *src, const bool do_id_user)
3286{
3287 if (src == nullptr) {
3288 return nullptr;
3289 }
3290 void *result = nullptr;
3291 constexpr const char *func = __func__;
3292 socket_data_to_static_type(type, [&]<typename T>() {
3293 const T &src_value = *static_cast<const T *>(src);
3294 if constexpr (std::is_same_v<T, bNodeSocketValueMenu>) {
3295 T *dst = MEM_new<T>(func, src_value);
3296 /* Copy of shared data pointer. */
3297 if (dst->enum_items) {
3298 dst->enum_items->add_user();
3299 }
3300 result = dst;
3301 }
3302 else {
3303 result = MEM_new<T>(func, src_value);
3304 }
3305 });
3306 if (do_id_user) {
3308 }
3309 return result;
3310}
3311
3313 void *dst,
3314 const void *src,
3315 const bool do_id_user)
3316{
3317 if (dst == nullptr || src == nullptr) {
3318 return;
3319 }
3320 if (do_id_user) {
3322 }
3323 socket_data_to_static_type(type, [&]<typename T>() {
3324 T &dst_value = *static_cast<T *>(dst);
3325 const T &src_value = *static_cast<const T *>(src);
3326 if constexpr (std::is_same_v<T, bNodeSocketValueMenu>) {
3327 const RuntimeNodeEnumItems *const src_items = src_value.enum_items;
3328 if (dst_value.enum_items != src_items) {
3329 if (dst_value.enum_items) {
3330 dst_value.enum_items->remove_user_and_delete_if_last();
3331 }
3332 if (src_items) {
3333 src_items->add_user();
3334 }
3335 }
3336 dst_value = src_value;
3337 }
3338 else {
3339 dst_value = src_value;
3340 }
3341 });
3342 if (do_id_user) {
3344 }
3345}
3346
3347void socket_value_free(const eNodeSocketDatatype type, void *data, const bool do_id_user)
3348{
3349 if (data == nullptr) {
3350 return;
3351 }
3352 if (do_id_user) {
3354 }
3355 socket_data_to_static_type(type, [&]<typename T>() {
3356 if constexpr (std::is_same_v<T, bNodeSocketValueMenu>) {
3357 auto &value = *static_cast<bNodeSocketValueMenu *>(data);
3358 if (value.enum_items) {
3359 /* Release shared data pointer. */
3360 value.enum_items->remove_user_and_delete_if_last();
3361 }
3362 MEM_delete(&value);
3363 }
3364 else {
3365 MEM_delete(static_cast<T *>(data));
3366 }
3367 });
3368}
3369
3370static void node_socket_free_default_value(bNodeSocket *sock, const bool do_id_user)
3371{
3372 if (sock->default_value == nullptr) {
3373 return;
3374 }
3375
3376 socket_value_free(eNodeSocketDatatype(sock->type), sock->default_value, do_id_user);
3377 sock->default_value = nullptr;
3378}
3379
3381 bNode & /*node*/,
3382 bNodeSocket &sock,
3383 const StringRefNull idname)
3384{
3385 bNodeSocketType *socktype = node_socket_type_find(idname);
3386
3387 if (!socktype) {
3388 CLOG_ERROR(&LOG, "node socket type %s undefined", idname.c_str());
3389 return;
3390 }
3391
3392 if (sock.default_value) {
3393 if (sock.type != socktype->type) {
3394 /* Only reallocate the default value if the type changed so that UI data like min and max
3395 * isn't removed. This assumes that the default value is stored in the same format for all
3396 * socket types with the same #eNodeSocketDatatype. */
3397 node_socket_free_default_value(&sock, true);
3398 }
3399 else {
3400 /* Update the socket subtype when the storage isn't freed and recreated. */
3401 switch (sock.type) {
3402 case SOCK_FLOAT: {
3403 sock.default_value_typed<bNodeSocketValueFloat>()->subtype = socktype->subtype;
3404 break;
3405 }
3406 case SOCK_VECTOR: {
3407 sock.default_value_typed<bNodeSocketValueVector>()->subtype = socktype->subtype;
3408 break;
3409 }
3410 case SOCK_INT: {
3411 sock.default_value_typed<bNodeSocketValueInt>()->subtype = socktype->subtype;
3412 break;
3413 }
3414 case SOCK_STRING: {
3415 sock.default_value_typed<bNodeSocketValueString>()->subtype = socktype->subtype;
3416 break;
3417 }
3418 case SOCK_RGBA:
3419 case SOCK_SHADER:
3420 case SOCK_BOOLEAN:
3421 case SOCK_ROTATION:
3422 case SOCK_MATRIX:
3423 case SOCK_CUSTOM:
3424 case SOCK_OBJECT:
3425 case SOCK_IMAGE:
3426 case SOCK_GEOMETRY:
3427 case SOCK_COLLECTION:
3428 case SOCK_TEXTURE:
3429 case SOCK_MATERIAL:
3430 case SOCK_FONT:
3431 case SOCK_SCENE:
3432 case SOCK_TEXT_ID:
3433 case SOCK_MASK:
3434 case SOCK_SOUND:
3435 case SOCK_MENU:
3436 case SOCK_BUNDLE:
3437 case SOCK_CLOSURE:
3438 case SOCK_INT_VECTOR:
3439 break;
3440 }
3441 }
3442 }
3443
3444 idname.copy_utf8_truncated(sock.idname);
3445 node_socket_set_typeinfo(&ntree, &sock, socktype);
3446}
3447
3449 bNodeTree *ntree, bNode *node, bNodeSocket *sock, const int type, const int subtype)
3450{
3451 const std::optional<StringRefNull> idname = node_static_socket_type(type, subtype);
3452
3453 if (!idname.has_value()) {
3454 CLOG_ERROR(&LOG, "static node socket type %d undefined", type);
3455 return;
3456 }
3457
3458 node_modify_socket_type(*ntree, *node, *sock, *idname);
3459}
3460
3462 bNode &node,
3463 const eNodeSocketInOut in_out,
3464 const StringRefNull idname,
3465 const StringRefNull identifier,
3466 const StringRefNull name)
3467{
3468 BLI_assert(!node.is_frame());
3469 BLI_assert(!(in_out == SOCK_IN && node.is_group_input()));
3470 BLI_assert(!(in_out == SOCK_OUT && node.is_group_output()));
3471
3472 ListBaseT<bNodeSocket> *lb = (in_out == SOCK_IN ? &node.inputs : &node.outputs);
3473 bNodeSocket *sock = make_socket(&ntree, &node, in_out, lb, idname, identifier, name);
3474
3475 BLI_remlink(lb, sock); /* does nothing for new socket */
3476 BLI_addtail(lb, sock);
3477
3478 BKE_ntree_update_tag_socket_new(&ntree, sock);
3479
3480 return sock;
3481}
3482
3484{
3485 /*
3486 * Cannot rely on type==SOCK_CUSTOM here, because type is 0 by default
3487 * and can be changed on custom sockets.
3488 */
3489 return RNA_struct_is_a(stype.ext_socket.srna, RNA_NodeSocketStandard);
3490}
3491
3492std::optional<StringRefNull> node_static_socket_type(const int type,
3493 const int subtype,
3494 const std::optional<int> dimensions)
3495{
3496 BLI_assert(!(dimensions.has_value() && !ELEM(type, SOCK_VECTOR, SOCK_INT_VECTOR)));
3497
3498 switch (type) {
3499 case SOCK_FLOAT:
3500 switch (PropertySubType(subtype)) {
3501 case PROP_UNSIGNED:
3502 return "NodeSocketFloatUnsigned";
3503 case PROP_PERCENTAGE:
3504 return "NodeSocketFloatPercentage";
3505 case PROP_FACTOR:
3506 return "NodeSocketFloatFactor";
3507 case PROP_MASS:
3508 return "NodeSocketFloatMass";
3509 case PROP_ANGLE:
3510 return "NodeSocketFloatAngle";
3511 case PROP_TIME:
3512 return "NodeSocketFloatTime";
3513 case PROP_TIME_ABSOLUTE:
3514 return "NodeSocketFloatTimeAbsolute";
3515 case PROP_DISTANCE:
3516 return "NodeSocketFloatDistance";
3517 case PROP_WAVELENGTH:
3518 return "NodeSocketFloatWavelength";
3520 return "NodeSocketFloatColorTemperature";
3521 case PROP_FREQUENCY:
3522 return "NodeSocketFloatFrequency";
3523 case PROP_PIXEL:
3524 return "NodeSocketFloatPixel";
3525 case PROP_NONE:
3526 default:
3527 return "NodeSocketFloat";
3528 }
3529 case SOCK_INT:
3530 switch (PropertySubType(subtype)) {
3531 case PROP_UNSIGNED:
3532 return "NodeSocketIntUnsigned";
3533 case PROP_PERCENTAGE:
3534 return "NodeSocketIntPercentage";
3535 case PROP_FACTOR:
3536 return "NodeSocketIntFactor";
3537 case PROP_PIXEL:
3538 return "NodeSocketIntPixel";
3539 case PROP_NONE:
3540 default:
3541 return "NodeSocketInt";
3542 }
3543 case SOCK_BOOLEAN:
3544 return "NodeSocketBool";
3545 case SOCK_ROTATION:
3546 return "NodeSocketRotation";
3547 case SOCK_MATRIX:
3548 return "NodeSocketMatrix";
3549 case SOCK_VECTOR:
3550 if (!dimensions.has_value() || dimensions.value() == 3) {
3551 switch (PropertySubType(subtype)) {
3552 case PROP_FACTOR:
3553 return "NodeSocketVectorFactor";
3554 case PROP_PERCENTAGE:
3555 return "NodeSocketVectorPercentage";
3556 case PROP_TRANSLATION:
3557 return "NodeSocketVectorTranslation";
3558 case PROP_DIRECTION:
3559 return "NodeSocketVectorDirection";
3560 case PROP_VELOCITY:
3561 return "NodeSocketVectorVelocity";
3562 case PROP_ACCELERATION:
3563 return "NodeSocketVectorAcceleration";
3564 case PROP_EULER:
3565 return "NodeSocketVectorEuler";
3566 case PROP_XYZ:
3567 return "NodeSocketVectorXYZ";
3568 case PROP_PIXEL:
3569 return "NodeSocketVectorPixel";
3570 case PROP_NONE:
3571 default:
3572 return "NodeSocketVector";
3573 }
3574 }
3575 else if (dimensions.value() == 2) {
3576 switch (PropertySubType(subtype)) {
3577 case PROP_FACTOR:
3578 return "NodeSocketVectorFactor2D";
3579 case PROP_PERCENTAGE:
3580 return "NodeSocketVectorPercentage2D";
3581 case PROP_TRANSLATION:
3582 return "NodeSocketVectorTranslation2D";
3583 case PROP_DIRECTION:
3584 return "NodeSocketVectorDirection2D";
3585 case PROP_VELOCITY:
3586 return "NodeSocketVectorVelocity2D";
3587 case PROP_ACCELERATION:
3588 return "NodeSocketVectorAcceleration2D";
3589 case PROP_EULER:
3590 return "NodeSocketVectorEuler2D";
3591 case PROP_XYZ:
3592 return "NodeSocketVectorXYZ2D";
3593 case PROP_PIXEL:
3594 return "NodeSocketVectorPixel2D";
3595 case PROP_NONE:
3596 default:
3597 return "NodeSocketVector2D";
3598 }
3599 }
3600 else if (dimensions.value() == 4) {
3601 switch (PropertySubType(subtype)) {
3602 case PROP_FACTOR:
3603 return "NodeSocketVectorFactor4D";
3604 case PROP_PERCENTAGE:
3605 return "NodeSocketVectorPercentage4D";
3606 case PROP_TRANSLATION:
3607 return "NodeSocketVectorTranslation4D";
3608 case PROP_DIRECTION:
3609 return "NodeSocketVectorDirection4D";
3610 case PROP_VELOCITY:
3611 return "NodeSocketVectorVelocity4D";
3612 case PROP_ACCELERATION:
3613 return "NodeSocketVectorAcceleration4D";
3614 case PROP_EULER:
3615 return "NodeSocketVectorEuler4D";
3616 case PROP_XYZ:
3617 return "NodeSocketVectorXYZ4D";
3618 case PROP_PIXEL:
3619 return "NodeSocketVectorPixel4D";
3620 case PROP_NONE:
3621 default:
3622 return "NodeSocketVector4D";
3623 }
3624 }
3625 else {
3627 return "NodeSocketVector";
3628 }
3629 case SOCK_INT_VECTOR:
3630 if (!dimensions.has_value() || dimensions.value() == 3) {
3631 switch (PropertySubType(subtype)) {
3632 case PROP_UNSIGNED:
3633 return "NodeSocketIntVectorUnsigned3D";
3634 case PROP_FACTOR:
3635 return "NodeSocketIntVectorFactor3D";
3636 case PROP_PERCENTAGE:
3637 return "NodeSocketIntVectorPercentage3D";
3638 case PROP_PIXEL:
3639 return "NodeSocketIntVectorPixel3D";
3640 case PROP_NONE:
3641 default:
3642 return "NodeSocketIntVector3D";
3643 }
3644 }
3645 else if (dimensions.value() == 2) {
3646 switch (PropertySubType(subtype)) {
3647 case PROP_UNSIGNED:
3648 return "NodeSocketIntVectorUnsigned2D";
3649 case PROP_FACTOR:
3650 return "NodeSocketIntVectorFactor2D";
3651 case PROP_PERCENTAGE:
3652 return "NodeSocketIntVectorPercentage2D";
3653 case PROP_PIXEL:
3654 return "NodeSocketIntVectorPixel2D";
3655 case PROP_NONE:
3656 default:
3657 return "NodeSocketIntVector2D";
3658 }
3659 }
3660 else {
3662 return "NodeSocketIntVector3D";
3663 }
3664 case SOCK_RGBA:
3665 return "NodeSocketColor";
3666 case SOCK_STRING:
3667 switch (PropertySubType(subtype)) {
3668 case PROP_FILEPATH:
3669 return "NodeSocketStringFilePath";
3670 default:
3671 return "NodeSocketString";
3672 }
3673 case SOCK_SHADER:
3674 return "NodeSocketShader";
3675 case SOCK_OBJECT:
3676 return "NodeSocketObject";
3677 case SOCK_IMAGE:
3678 return "NodeSocketImage";
3679 case SOCK_GEOMETRY:
3680 return "NodeSocketGeometry";
3681 case SOCK_COLLECTION:
3682 return "NodeSocketCollection";
3683 case SOCK_TEXTURE:
3684 return "NodeSocketTexture";
3685 case SOCK_MATERIAL:
3686 return "NodeSocketMaterial";
3687 case SOCK_FONT:
3688 return "NodeSocketFont";
3689 case SOCK_SCENE:
3690 return "NodeSocketScene";
3691 case SOCK_TEXT_ID:
3692 return "NodeSocketText";
3693 case SOCK_MASK:
3694 return "NodeSocketMask";
3695 case SOCK_SOUND:
3696 return "NodeSocketSound";
3697 case SOCK_MENU:
3698 return "NodeSocketMenu";
3699 case SOCK_BUNDLE:
3700 return "NodeSocketBundle";
3701 case SOCK_CLOSURE:
3702 return "NodeSocketClosure";
3703 case SOCK_CUSTOM:
3704 break;
3705 }
3706 return std::nullopt;
3707}
3708
3709std::optional<StringRefNull> node_static_socket_interface_type_new(
3710 const int type, const int subtype, const std::optional<int> dimensions)
3711{
3712 switch (type) {
3713 case SOCK_FLOAT:
3714 switch (PropertySubType(subtype)) {
3715 case PROP_UNSIGNED:
3716 return "NodeTreeInterfaceSocketFloatUnsigned";
3717 case PROP_PERCENTAGE:
3718 return "NodeTreeInterfaceSocketFloatPercentage";
3719 case PROP_FACTOR:
3720 return "NodeTreeInterfaceSocketFloatFactor";
3721 case PROP_MASS:
3722 return "NodeTreeInterfaceSocketFloatMass";
3723 case PROP_ANGLE:
3724 return "NodeTreeInterfaceSocketFloatAngle";
3725 case PROP_TIME:
3726 return "NodeTreeInterfaceSocketFloatTime";
3727 case PROP_TIME_ABSOLUTE:
3728 return "NodeTreeInterfaceSocketFloatTimeAbsolute";
3729 case PROP_DISTANCE:
3730 return "NodeTreeInterfaceSocketFloatDistance";
3731 case PROP_WAVELENGTH:
3732 return "NodeTreeInterfaceSocketFloatWavelength";
3734 return "NodeTreeInterfaceSocketFloatColorTemperature";
3735 case PROP_FREQUENCY:
3736 return "NodeTreeInterfaceSocketFloatFrequency";
3737 case PROP_PIXEL:
3738 return "NodeTreeInterfaceSocketFloatPixel";
3739 case PROP_NONE:
3740 default:
3741 return "NodeTreeInterfaceSocketFloat";
3742 }
3743 case SOCK_INT:
3744 switch (PropertySubType(subtype)) {
3745 case PROP_UNSIGNED:
3746 return "NodeTreeInterfaceSocketIntUnsigned";
3747 case PROP_PERCENTAGE:
3748 return "NodeTreeInterfaceSocketIntPercentage";
3749 case PROP_FACTOR:
3750 return "NodeTreeInterfaceSocketIntFactor";
3751 case PROP_PIXEL:
3752 return "NodeTreeInterfaceSocketIntPixel";
3753 case PROP_NONE:
3754 default:
3755 return "NodeTreeInterfaceSocketInt";
3756 }
3757 case SOCK_BOOLEAN:
3758 return "NodeTreeInterfaceSocketBool";
3759 case SOCK_ROTATION:
3760 return "NodeTreeInterfaceSocketRotation";
3761 case SOCK_MATRIX:
3762 return "NodeTreeInterfaceSocketMatrix";
3763 case SOCK_VECTOR:
3764 if (!dimensions.has_value() || dimensions.value() == 3) {
3765 switch (PropertySubType(subtype)) {
3766 case PROP_FACTOR:
3767 return "NodeTreeInterfaceSocketVectorFactor";
3768 case PROP_PERCENTAGE:
3769 return "NodeTreeInterfaceSocketVectorPercentage";
3770 case PROP_TRANSLATION:
3771 return "NodeTreeInterfaceSocketVectorTranslation";
3772 case PROP_DIRECTION:
3773 return "NodeTreeInterfaceSocketVectorDirection";
3774 case PROP_VELOCITY:
3775 return "NodeTreeInterfaceSocketVectorVelocity";
3776 case PROP_ACCELERATION:
3777 return "NodeTreeInterfaceSocketVectorAcceleration";
3778 case PROP_EULER:
3779 return "NodeTreeInterfaceSocketVectorEuler";
3780 case PROP_XYZ:
3781 return "NodeTreeInterfaceSocketVectorXYZ";
3782 case PROP_PIXEL:
3783 return "NodeTreeInterfaceSocketVectorPixel";
3784 case PROP_NONE:
3785 default:
3786 return "NodeTreeInterfaceSocketVector";
3787 }
3788 }
3789 else if (dimensions.value() == 2) {
3790 switch (PropertySubType(subtype)) {
3791 case PROP_FACTOR:
3792 return "NodeTreeInterfaceSocketVectorFactor2D";
3793 case PROP_PERCENTAGE:
3794 return "NodeTreeInterfaceSocketVectorPercentage2D";
3795 case PROP_TRANSLATION:
3796 return "NodeTreeInterfaceSocketVectorTranslation2D";
3797 case PROP_DIRECTION:
3798 return "NodeTreeInterfaceSocketVectorDirection2D";
3799 case PROP_VELOCITY:
3800 return "NodeTreeInterfaceSocketVectorVelocity2D";
3801 case PROP_ACCELERATION:
3802 return "NodeTreeInterfaceSocketVectorAcceleration2D";
3803 case PROP_EULER:
3804 return "NodeTreeInterfaceSocketVectorEuler2D";
3805 case PROP_XYZ:
3806 return "NodeTreeInterfaceSocketVectorXYZ2D";
3807 case PROP_PIXEL:
3808 return "NodeTreeInterfaceSocketVectorPixel2D";
3809 case PROP_NONE:
3810 default:
3811 return "NodeTreeInterfaceSocketVector2D";
3812 }
3813 }
3814 else if (dimensions.value() == 4) {
3815 switch (PropertySubType(subtype)) {
3816 case PROP_FACTOR:
3817 return "NodeTreeInterfaceSocketVectorFactor4D";
3818 case PROP_PERCENTAGE:
3819 return "NodeTreeInterfaceSocketVectorPercentage4D";
3820 case PROP_TRANSLATION:
3821 return "NodeTreeInterfaceSocketVectorTranslation4D";
3822 case PROP_DIRECTION:
3823 return "NodeTreeInterfaceSocketVectorDirection4D";
3824 case PROP_VELOCITY:
3825 return "NodeTreeInterfaceSocketVectorVelocity4D";
3826 case PROP_ACCELERATION:
3827 return "NodeTreeInterfaceSocketVectorAcceleration4D";
3828 case PROP_EULER:
3829 return "NodeTreeInterfaceSocketVectorEuler4D";
3830 case PROP_XYZ:
3831 return "NodeTreeInterfaceSocketVectorXYZ4D";
3832 case PROP_PIXEL:
3833 return "NodeTreeInterfaceSocketVectorPixel4D";
3834 case PROP_NONE:
3835 default:
3836 return "NodeTreeInterfaceSocketVector4D";
3837 }
3838 }
3839 else {
3841 return "NodeTreeInterfaceSocketVector";
3842 }
3843 case SOCK_INT_VECTOR:
3844 if (!dimensions.has_value() || dimensions.value() == 3) {
3845 switch (PropertySubType(subtype)) {
3846 case PROP_UNSIGNED:
3847 return "NodeTreeInterfaceSocketIntVectorUnsigned3D";
3848 case PROP_FACTOR:
3849 return "NodeTreeInterfaceSocketIntVectorFactor3D";
3850 case PROP_PERCENTAGE:
3851 return "NodeTreeInterfaceSocketIntVectorPercentage3D";
3852 case PROP_PIXEL:
3853 return "NodeTreeInterfaceSocketIntVectorPixel3D";
3854 case PROP_NONE:
3855 default:
3856 return "NodeTreeInterfaceSocketIntVector3D";
3857 }
3858 }
3859 else if (dimensions.value() == 2) {
3860 switch (PropertySubType(subtype)) {
3861 case PROP_UNSIGNED:
3862 return "NodeTreeInterfaceSocketIntVectorUnsigned2D";
3863 case PROP_FACTOR:
3864 return "NodeTreeInterfaceSocketIntVectorFactor2D";
3865 case PROP_PERCENTAGE:
3866 return "NodeTreeInterfaceSocketIntVectorPercentage2D";
3867 case PROP_PIXEL:
3868 return "NodeTreeInterfaceSocketIntVectorPixel2D";
3869 case PROP_NONE:
3870 default:
3871 return "NodeTreeInterfaceSocketIntVector2D";
3872 }
3873 }
3874 else {
3876 return "NodeTreeInterfaceSocketIntVector3D";
3877 }
3878 case SOCK_RGBA:
3879 return "NodeTreeInterfaceSocketColor";
3880 case SOCK_STRING:
3881 switch (PropertySubType(subtype)) {
3882 case PROP_FILEPATH:
3883 return "NodeTreeInterfaceSocketStringFilePath";
3884 default:
3885 return "NodeTreeInterfaceSocketString";
3886 }
3887 case SOCK_SHADER:
3888 return "NodeTreeInterfaceSocketShader";
3889 case SOCK_OBJECT:
3890 return "NodeTreeInterfaceSocketObject";
3891 case SOCK_IMAGE:
3892 return "NodeTreeInterfaceSocketImage";
3893 case SOCK_GEOMETRY:
3894 return "NodeTreeInterfaceSocketGeometry";
3895 case SOCK_COLLECTION:
3896 return "NodeTreeInterfaceSocketCollection";
3897 case SOCK_TEXTURE:
3898 return "NodeTreeInterfaceSocketTexture";
3899 case SOCK_MATERIAL:
3900 return "NodeTreeInterfaceSocketMaterial";
3901 case SOCK_FONT:
3902 return "NodeTreeInterfaceSocketFont";
3903 case SOCK_SCENE:
3904 return "NodeTreeInterfaceSocketScene";
3905 case SOCK_TEXT_ID:
3906 return "NodeTreeInterfaceSocketText";
3907 case SOCK_MASK:
3908 return "NodeTreeInterfaceSocketMask";
3909 case SOCK_SOUND:
3910 return "NodeTreeInterfaceSocketSound";
3911 case SOCK_MENU:
3912 return "NodeTreeInterfaceSocketMenu";
3913 case SOCK_BUNDLE:
3914 return "NodeTreeInterfaceSocketBundle";
3915 case SOCK_CLOSURE:
3916 return "NodeTreeInterfaceSocketClosure";
3917 case SOCK_CUSTOM:
3918 break;
3919 }
3920 return std::nullopt;
3921}
3922
3923std::optional<StringRefNull> node_static_socket_label(const int type, const int /*subtype*/)
3924{
3925 switch (type) {
3926 case SOCK_FLOAT:
3927 return "Float";
3928 case SOCK_INT:
3929 return "Integer";
3930 case SOCK_BOOLEAN:
3931 return "Boolean";
3932 case SOCK_ROTATION:
3933 return "Rotation";
3934 case SOCK_MATRIX:
3935 return "Matrix";
3936 case SOCK_VECTOR:
3937 return "Vector";
3938 case SOCK_RGBA:
3939 return "Color";
3940 case SOCK_STRING:
3941 return "String";
3942 case SOCK_SHADER:
3943 return "Shader";
3944 case SOCK_OBJECT:
3945 return "Object";
3946 case SOCK_IMAGE:
3947 return "Image";
3948 case SOCK_GEOMETRY:
3949 return "Geometry";
3950 case SOCK_COLLECTION:
3951 return "Collection";
3952 case SOCK_TEXTURE:
3953 return "Texture";
3954 case SOCK_MATERIAL:
3955 return "Material";
3956 case SOCK_FONT:
3957 return "Font";
3958 case SOCK_SCENE:
3959 return "Scene";
3960 case SOCK_TEXT_ID:
3961 return "Text";
3962 case SOCK_MASK:
3963 return "Mask";
3964 case SOCK_SOUND:
3965 return "Sound";
3966 case SOCK_MENU:
3967 return "Menu";
3968 case SOCK_BUNDLE:
3969 return "Bundle";
3970 case SOCK_CLOSURE:
3971 return "Closure";
3972 case SOCK_INT_VECTOR:
3973 return "Integer Vector";
3974 case SOCK_CUSTOM:
3975 break;
3976 }
3977 return std::nullopt;
3978}
3979
3981 bNode &node,
3982 eNodeSocketInOut in_out,
3983 int type,
3984 int subtype,
3985 const StringRefNull identifier,
3986 const StringRefNull name)
3987{
3988 const std::optional<StringRefNull> idname = node_static_socket_type(type, subtype);
3989
3990 if (!idname.has_value()) {
3991 CLOG_ERROR(&LOG, "static node socket type %d undefined", type);
3992 return nullptr;
3993 }
3994
3995 bNodeSocket *sock = node_add_socket(ntree, node, in_out, *idname, identifier, name);
3996 sock->type = eNodeSocketDatatype(type);
3997 return sock;
3998}
3999
4000static void node_socket_free(bNodeSocket *sock, const bool do_id_user)
4001{
4002 if (sock->prop) {
4003 IDP_FreeProperty_ex(sock->prop, do_id_user);
4004 }
4005
4006 if (sock->default_value) {
4007 node_socket_free_default_value(sock, do_id_user);
4008 }
4009 if (sock->default_attribute_name) {
4010 MEM_delete(sock->default_attribute_name);
4011 }
4012 MEM_delete(sock->runtime);
4013}
4014
4016{
4017 node_remove_socket_ex(ntree, node, sock, true);
4018}
4019
4020void node_remove_socket_ex(bNodeTree &ntree, bNode &node, bNodeSocket &sock, const bool do_id_user)
4021{
4022 for (bNodeLink &link : ntree.links.items_mutable()) {
4023 if (link.fromsock == &sock || link.tosock == &sock) {
4024 node_remove_link(&ntree, link);
4025 }
4026 }
4027
4028 for (const int64_t i : node.runtime->internal_links.index_range()) {
4029 const bNodeInternalLink &link = node.runtime->internal_links[i];
4030 if (link.in == &sock || link.out == &sock) {
4031 node.runtime->internal_links.remove_and_reorder(i);
4033 break;
4034 }
4035 }
4036
4037 /* this is fast, this way we don't need an in_out argument */
4038 BLI_remlink(&node.inputs, &sock);
4039 BLI_remlink(&node.outputs, &sock);
4040
4041 node_socket_free(&sock, do_id_user);
4042 MEM_delete(&sock);
4043
4045}
4046
4048{
4049 return reinterpret_cast<bNode *>(
4050 BLI_findstring(&ntree.nodes, name.c_str(), offsetof(bNode, name)));
4051}
4052
4054{
4055 ntree.ensure_topology_cache();
4056 return socket.owner_node();
4057}
4058
4059const bNode &node_find_node(const bNodeTree &ntree, const bNodeSocket &socket)
4060{
4061 ntree.ensure_topology_cache();
4062 return socket.owner_node();
4063}
4064
4066{
4067 for (bNode *node : ntree.all_nodes()) {
4068 const ListBaseT<bNodeSocket> *sockets = (socket.in_out == SOCK_IN) ? &node->inputs :
4069 &node->outputs;
4070 for (const bNodeSocket &socket_iter : *sockets) {
4071 if (&socket_iter == &socket) {
4072 return node;
4073 }
4074 }
4075 }
4076 return nullptr;
4077}
4078
4080 const StringRef identifier)
4081{
4082 ntree.ensure_interface_cache();
4083 for (const bNodeTreeInterfaceSocket *input : ntree.interface_inputs()) {
4084 if (input->identifier == identifier) {
4085 return input;
4086 }
4087 }
4088 return nullptr;
4089}
4090
4092 const bNodeTree &ntree, const StringRef identifier)
4093{
4094 ntree.ensure_interface_cache();
4095 for (const bNodeTreeInterfaceSocket *input : ntree.interface_outputs()) {
4096 if (input->identifier == identifier) {
4097 return input;
4098 }
4099 }
4100 return nullptr;
4101}
4102
4104{
4105 bNode *parent_iter = &node;
4106 while (parent_iter->parent != nullptr) {
4107 parent_iter = parent_iter->parent;
4108 }
4109 if (!parent_iter->is_frame()) {
4110 return nullptr;
4111 }
4112 return parent_iter;
4113}
4114
4115bool node_is_parent_and_child(const bNode &parent, const bNode &child)
4116{
4117 for (const bNode *child_iter = &child; child_iter; child_iter = child_iter->parent) {
4118 if (child_iter == &parent) {
4119 return true;
4120 }
4121 }
4122 return false;
4123}
4124
4126 const bNode *node_start,
4127 bool (*callback)(bNode *, bNode *, void *, const bool),
4128 void *userdata,
4129 const bool reversed)
4130{
4131 for (const bNodeLink &link : ntree->links) {
4132 if ((link.flag & NODE_LINK_VALID) == 0) {
4133 /* Skip links marked as cyclic. */
4134 continue;
4135 }
4136 /* Is the link part of the chain meaning node_start == fromnode
4137 * (or tonode for reversed case)? */
4138 if (!reversed) {
4139 if (link.fromnode != node_start) {
4140 continue;
4141 }
4142 }
4143 else {
4144 if (link.tonode != node_start) {
4145 continue;
4146 }
4147 }
4148
4149 if (!callback(link.fromnode, link.tonode, userdata, reversed)) {
4150 return;
4151 }
4153 ntree, reversed ? link.fromnode : link.tonode, callback, userdata, reversed);
4154 }
4155}
4156
4157static void iter_backwards_ex(const bNodeTree *ntree,
4158 bNode *node_start,
4159 bool (*callback)(bNode *, bNode *, void *),
4160 void *userdata,
4161 const char recursion_mask)
4162{
4163 Stack<bNode *> stack;
4164 Stack<bNode *> zone_stack;
4165 stack.push(node_start);
4166
4167 while (!stack.is_empty() || !zone_stack.is_empty()) {
4168 bNode *node = !stack.is_empty() ? stack.pop() : zone_stack.pop();
4169
4170 for (bNodeSocket &sock : node->inputs) {
4171 bNodeLink *link = sock.link;
4172 if (link == nullptr) {
4173 continue;
4174 }
4175 if ((link->flag & NODE_LINK_VALID) == 0) {
4176 /* Skip links marked as cyclic. */
4177 continue;
4178 }
4179 if (link->fromnode->runtime->iter_flag & recursion_mask) {
4180 continue;
4181 }
4182
4183 link->fromnode->runtime->iter_flag |= recursion_mask;
4184
4185 if (!callback(link->fromnode, link->tonode, userdata)) {
4186 break;
4187 }
4188 stack.push(link->fromnode);
4189 }
4190 /* Zone input nodes are implicitly linked to their corresponding zone output nodes,
4191 * even if there is no bNodeLink between them. */
4192 if (const bNodeZoneType *zone_type = zone_type_by_node_type(node->type_legacy)) {
4193 if (zone_type->output_type == node->type_legacy) {
4194 if (bNode *zone_input_node = const_cast<bNode *>(
4195 zone_type->get_corresponding_input(*ntree, *node)))
4196 {
4197 if (callback(zone_input_node, node, userdata)) {
4198 zone_stack.push(zone_input_node);
4199 }
4200 }
4201 }
4202 }
4203 }
4204}
4205
4207 bNode *node_start,
4208 bool (*callback)(bNode *, bNode *, void *),
4209 void *userdata,
4210 const int recursion_lvl)
4211{
4212 if (!node_start) {
4213 return;
4214 }
4215
4216 /* Limited by iter_flag type. */
4217 BLI_assert(recursion_lvl < 8);
4218 const char recursion_mask = (1 << recursion_lvl);
4219
4220 /* Reset flag. */
4221 for (const bNode &node : ntree->nodes) {
4222 node.runtime->iter_flag &= ~recursion_mask;
4223 }
4224
4225 iter_backwards_ex(ntree, node_start, callback, userdata, recursion_mask);
4226}
4227
4228void node_parents_iterator(bNode *node, bool (*callback)(bNode *, void *), void *userdata)
4229{
4230 if (node->parent) {
4231 if (!callback(node->parent, userdata)) {
4232 return;
4233 }
4234 node_parents_iterator(node->parent, callback, userdata);
4235 }
4236}
4237
4239{
4241 &ntree.nodes, &node, DATA_("Node"), '.', offsetof(bNode, name), sizeof(node.name));
4242}
4243
4245{
4247
4248 /* In the unlikely case that the random ID doesn't match, choose a new one until it does. */
4249 int32_t new_id = id_rng.get_int32();
4250 while (ntree.runtime->nodes_by_id.contains_as(new_id) || new_id <= 0) {
4251 new_id = id_rng.get_int32();
4252 }
4253
4254 node.identifier = new_id;
4256 node.runtime->index_in_tree = ntree.runtime->nodes_by_id.index_range().last();
4257 BLI_assert(node.runtime->index_in_tree == ntree.runtime->nodes_by_id.index_of(&node));
4258}
4259
4261 bNodeTree &ntree,
4262 const UString idname,
4263 std::optional<int> unique_identifier)
4264{
4265 bNode *node = MEM_new<bNode>(__func__);
4266 node->runtime = MEM_new<bNodeRuntime>(__func__);
4267 BLI_addtail(&ntree.nodes, node);
4268 if (unique_identifier) {
4269 node->identifier = *unique_identifier;
4271 }
4272 else {
4273 node_unique_id(ntree, *node);
4274 }
4275 node->ui_order = ntree.all_nodes().size();
4276 idname.ref().copy_utf8_truncated(node->idname);
4277
4279 node_set_typeinfo(C, &ntree, node, node_type_find(idname));
4280 return node;
4281}
4282
4283bNode *node_add_static_node(const bContext *C, bNodeTree &ntree, const int type)
4284{
4285 std::optional<UString> idname;
4286
4287 for (bNodeType *ntype : node_types_get()) {
4288 /* Do an extra poll here, because some int types are used
4289 * for multiple node types, this helps find the desired type. */
4290 if (ntype->type_legacy != type) {
4291 continue;
4292 }
4293
4294 const char *disabled_hint;
4295 if (ntype->poll && ntype->poll(ntype, &ntree, &disabled_hint)) {
4296 idname = ntype->idname;
4297 break;
4298 }
4299 }
4300 if (!idname) {
4301 CLOG_ERROR(&LOG, "static node type %d undefined", type);
4302 return nullptr;
4303 }
4304 return node_add_node(C, ntree, *idname);
4305}
4306
4307static void node_socket_copy(bNodeSocket *sock_dst, const bNodeSocket *sock_src, const int flag)
4308{
4309 sock_dst->runtime = MEM_new<bNodeSocketRuntime>(__func__);
4310 sock_dst->runtime->identifier_ustr = UString(sock_src->runtime->identifier_ustr);
4311 if (sock_src->prop) {
4312 sock_dst->prop = IDP_CopyProperty_ex(sock_src->prop, flag);
4313 }
4314
4315 if (sock_src->default_value) {
4317 sock_src->default_value,
4318 (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0);
4319 }
4320
4321 sock_dst->default_attribute_name = static_cast<char *>(
4322 MEM_dupalloc(sock_src->default_attribute_name));
4323
4324 sock_dst->stack_index = 0;
4325}
4326
4328 const bNode &node_src,
4329 const int flag,
4330 const std::optional<StringRefNull> dst_unique_name,
4331 const std::optional<int> dst_unique_identifier,
4333 const bool allow_duplicate_names)
4334{
4335 bNode *node_dst = MEM_new<bNode>(__func__, node_src);
4336 node_dst->runtime = MEM_new<bNodeRuntime>(__func__);
4337 if (dst_unique_name) {
4338 BLI_assert(dst_unique_name->size() < sizeof(node_dst->name));
4339 STRNCPY_UTF8(node_dst->name, dst_unique_name->c_str());
4340 }
4341 else if (dst_tree) {
4342 if (!allow_duplicate_names) {
4343 node_unique_name(*dst_tree, *node_dst);
4344 }
4345 }
4346 if (dst_unique_identifier) {
4347 node_dst->identifier = *dst_unique_identifier;
4348 if (dst_tree) {
4349 dst_tree->runtime->nodes_by_id.add_new(node_dst);
4350 }
4351 }
4352 else if (dst_tree) {
4353 node_unique_id(*dst_tree, *node_dst);
4354 }
4355
4356 /* Can be called for nodes outside a node tree (e.g. clipboard). */
4357 if (dst_tree) {
4358 BLI_addtail(&dst_tree->nodes, node_dst);
4359 }
4360
4361 node_dst->inputs.clear_no_delete();
4362 for (const bNodeSocket &src_socket : node_src.inputs) {
4363 bNodeSocket *dst_socket = MEM_dupalloc(&src_socket);
4364 node_socket_copy(dst_socket, &src_socket, flag);
4365 BLI_addtail(&node_dst->inputs, dst_socket);
4366 socket_map.add_new(&src_socket, dst_socket);
4367 }
4368
4369 node_dst->outputs.clear_no_delete();
4370 for (const bNodeSocket &src_socket : node_src.outputs) {
4371 bNodeSocket *dst_socket = MEM_dupalloc(&src_socket);
4372 node_socket_copy(dst_socket, &src_socket, flag);
4373 BLI_addtail(&node_dst->outputs, dst_socket);
4374 socket_map.add_new(&src_socket, dst_socket);
4375 }
4376
4377 if (node_src.prop) {
4378 node_dst->prop = IDP_CopyProperty_ex(node_src.prop, flag);
4379 }
4380 if (node_src.system_properties) {
4381 node_dst->system_properties = IDP_CopyProperty_ex(node_src.system_properties, flag);
4382 }
4383
4384 node_dst->panel_states_array = static_cast<bNodePanelState *>(
4385 MEM_dupalloc(node_src.panel_states_array));
4386
4387 node_dst->runtime->internal_links = node_src.runtime->internal_links;
4388 for (bNodeInternalLink &dst_link : node_dst->runtime->internal_links) {
4389 dst_link.in = socket_map.lookup(dst_link.in);
4390 dst_link.out = socket_map.lookup(dst_link.out);
4391 }
4392
4393 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
4394 id_us_plus(node_dst->id);
4395 }
4396
4397 if (node_src.typeinfo->copyfunc) {
4398 node_src.typeinfo->copyfunc(dst_tree, node_dst, &node_src);
4399 }
4400
4401 if (dst_tree) {
4402 BKE_ntree_update_tag_node_new(dst_tree, node_dst);
4403 }
4404
4405 /* Only call copy function when a copy is made for the main database, not
4406 * for cases like the dependency graph and localization. */
4407 if (node_dst->typeinfo->copyfunc_api && !(flag & LIB_ID_CREATE_NO_MAIN)) {
4409 reinterpret_cast<ID *>(dst_tree), RNA_Node, node_dst);
4410
4411 node_dst->typeinfo->copyfunc_api(&ptr, &node_src);
4412 }
4413
4414 return node_dst;
4415}
4416
4421[[nodiscard]] static bool store_socket_value(bNode &node,
4422 const bNodeSocket &socket,
4423 const void *value)
4424{
4425 if (!socket.is_output()) {
4426 return false;
4427 }
4428
4429 switch (node.type_legacy) {
4430 case FN_NODE_INPUT_BOOL:
4431 reinterpret_cast<NodeInputBool *>(node.storage)->boolean = *static_cast<const bool *>(value);
4432 return true;
4433 case SH_NODE_VALUE:
4434 /* The value is stored in the default value of the first output socket. */
4435 node.outputs.first()->default_value_typed<bNodeSocketValueFloat>()->value =
4436 *static_cast<const float *>(value);
4437 return true;
4438 case FN_NODE_INPUT_INT:
4439 reinterpret_cast<NodeInputInt *>(node.storage)->integer = *static_cast<const int *>(value);
4440 return true;
4442 copy_v3_v3(reinterpret_cast<NodeInputVector *>(node.storage)->vector,
4443 *static_cast<const float3 *>(value));
4444 return true;
4446 copy_v4_v4(reinterpret_cast<NodeInputColor *>(node.storage)->color,
4447 *static_cast<const ColorGeometry4f *>(value));
4448 return true;
4450 copy_v3_v3(reinterpret_cast<NodeInputRotation *>(node.storage)->rotation_euler,
4451 float3(math::to_euler(*static_cast<const math::Quaternion *>(value)).xyz()));
4452 return true;
4454 /* Handled separately for string copies. */
4455 return false;
4456 case GEO_NODE_IMAGE:
4460 node.id = *static_cast<ID *const *>(value);
4461 return true;
4462 default:
4463 break;
4464 }
4465 if (node.is_type("ShaderNodeCombineXYZ"_ustr)) {
4466 const float3 &vector = *static_cast<const float3 *>(value);
4467 node.input_socket(0).default_value_typed<bNodeSocketValueFloat>()->value = vector.x;
4468 node.input_socket(1).default_value_typed<bNodeSocketValueFloat>()->value = vector.y;
4469 node.input_socket(2).default_value_typed<bNodeSocketValueFloat>()->value = vector.z;
4470 return true;
4471 }
4472 if (node.is_type("GeometryNodeInputFont"_ustr)) {
4473 node.id = *static_cast<ID *const *>(value);
4474 return true;
4475 }
4476 if (node.is_type("FunctionNodeInputMenu"_ustr)) {
4477 reinterpret_cast<NodeInputMenu *>(node.storage)->value = *static_cast<const int *>(value);
4478 return true;
4479 }
4480 if (node.is_type("ShaderNodeRGB"_ustr) || node.is_type("CompositorNodeRGB"_ustr)) {
4481 copy_v4_v4(node.output_socket(0).default_value_typed<bNodeSocketValueRGBA>()->value,
4482 *static_cast<const ColorGeometry4f *>(value));
4483 return true;
4484 }
4485 if (node.is_type("ShaderNodeValue"_ustr)) {
4486 node.output_socket(0).default_value_typed<bNodeSocketValueFloat>()->value =
4487 *static_cast<const float *>(value);
4488 return true;
4489 }
4490
4491 return false;
4492}
4493
4494[[nodiscard]] static bool get_socket_value(bNodeSocket &socket, void *buffer)
4495{
4496 switch (socket.type) {
4497 case SOCK_BOOLEAN:
4498 case SOCK_INT:
4499 case SOCK_FLOAT:
4500 case SOCK_VECTOR:
4501 case SOCK_RGBA:
4502 case SOCK_IMAGE:
4503 case SOCK_TEXTURE:
4504 case SOCK_COLLECTION:
4505 case SOCK_OBJECT:
4506 case SOCK_MATERIAL:
4507 case SOCK_FONT:
4508 case SOCK_SCENE:
4509 case SOCK_TEXT_ID:
4510 case SOCK_MASK:
4511 case SOCK_SOUND:
4512 case SOCK_ROTATION:
4513 case SOCK_MENU:
4514 case SOCK_INT_VECTOR:
4515 socket.typeinfo->get_base_cpp_value(socket.default_value, buffer);
4516 return true;
4517 case SOCK_MATRIX:
4518 /* Matrix sockets currently have no default value. */
4519 return false;
4520 case SOCK_STRING:
4521 /* Handled separately for string copies. */
4522 return false;
4523 case SOCK_CUSTOM:
4524 case SOCK_SHADER:
4525 case SOCK_GEOMETRY:
4526 case SOCK_BUNDLE:
4527 case SOCK_CLOSURE:
4528 return false;
4529 }
4530
4531 return false;
4532}
4533
4535 bNodeTree &tree,
4536 bNodeSocket &src,
4537 bNodeSocket &dst)
4538{
4539 tree.ensure_topology_cache();
4540
4541 bNode &dst_node = dst.owner_node();
4542 bNode &src_node = src.owner_node();
4543
4545
4546 if (src.is_multi_input()) {
4547 /* Multi input sockets no have value. */
4548 return;
4549 }
4550 if (dst_node.is_reroute() || src_node.is_reroute()) {
4551 /* Reroute node can't have ownership of socket value directly. */
4552 return;
4553 }
4554 if (src.typeinfo->base_cpp_type == nullptr || dst.typeinfo->base_cpp_type == nullptr) {
4555 /* Not all socket types have a value type. */
4556 return;
4557 }
4558
4559 const CPPType &src_type = *src.typeinfo->base_cpp_type;
4560 const CPPType &dst_type = *dst.typeinfo->base_cpp_type;
4561 if (&src_type != &dst_type) {
4562 if (!convert.is_convertible(src_type, dst_type)) {
4563 return;
4564 }
4565 }
4566
4567 /* Special handling for strings because the generic code below can't handle them. */
4568 if (src.type == SOCK_STRING && dst.type == SOCK_STRING &&
4569 dst_node.is_type("FunctionNodeInputString"_ustr))
4570 {
4571 auto *src_value = static_cast<bNodeSocketValueString *>(src.default_value);
4572 auto *dst_storage = static_cast<NodeInputString *>(dst_node.storage);
4573 MEM_SAFE_DELETE(dst_storage->string);
4574 dst_storage->string = BLI_strdup_null(src_value->value);
4575 return;
4576 }
4577
4578 BUFFER_FOR_CPP_TYPE_VALUE(src_type, src_value);
4579 if (!get_socket_value(src, src_value)) {
4580 return;
4581 }
4582
4583 BUFFER_FOR_CPP_TYPE_VALUE(dst_type, dst_buffer);
4584 convert.convert_to_uninitialized(src_type, dst_type, src_value, dst_buffer);
4585 src_type.destruct(src_value);
4586
4587 if (!store_socket_value(dst_node, dst, dst_buffer)) {
4588 return;
4589 }
4590
4591 switch (src.type) {
4592 case SOCK_COLLECTION:
4593 src.default_value_typed<bNodeSocketValueCollection>()->value = nullptr;
4594 break;
4595 case SOCK_IMAGE:
4596 src.default_value_typed<bNodeSocketValueImage>()->value = nullptr;
4597 break;
4598 case SOCK_MATERIAL:
4599 src.default_value_typed<bNodeSocketValueMaterial>()->value = nullptr;
4600 break;
4601 case SOCK_TEXTURE:
4602 src.default_value_typed<bNodeSocketValueTexture>()->value = nullptr;
4603 break;
4604 case SOCK_OBJECT:
4605 src.default_value_typed<bNodeSocketValueObject>()->value = nullptr;
4606 break;
4607 case SOCK_FONT:
4608 src.default_value_typed<bNodeSocketValueFont>()->value = nullptr;
4609 break;
4610 case SOCK_SCENE:
4611 src.default_value_typed<bNodeSocketValueScene>()->value = nullptr;
4612 break;
4613 case SOCK_TEXT_ID:
4614 src.default_value_typed<bNodeSocketValueText>()->value = nullptr;
4615 break;
4616 case SOCK_MASK:
4617 src.default_value_typed<bNodeSocketValueMask>()->value = nullptr;
4618 break;
4619 case SOCK_SOUND:
4620 src.default_value_typed<bNodeSocketValueSound>()->value = nullptr;
4621 break;
4622 default:
4623 break;
4624 }
4625}
4626
4627static int node_count_links(const bNodeTree *ntree, const bNodeSocket *socket)
4628{
4629 int count = 0;
4630 for (const bNodeLink &link : ntree->links) {
4631 if (ELEM(socket, link.fromsock, link.tosock)) {
4632 count++;
4633 }
4634 }
4635 return count;
4636}
4637
4639 bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
4640{
4641 BLI_assert(ntree.all_nodes().contains(&fromnode));
4642 BLI_assert(ntree.all_nodes().contains(&tonode));
4643
4644 bNodeLink *link = nullptr;
4645 if (eNodeSocketInOut(fromsock.in_out) == SOCK_OUT && eNodeSocketInOut(tosock.in_out) == SOCK_IN)
4646 {
4647 link = MEM_new<bNodeLink>(__func__);
4648 BLI_addtail(&ntree.links, link);
4649 link->fromnode = &fromnode;
4650 link->fromsock = &fromsock;
4651 link->tonode = &tonode;
4652 link->tosock = &tosock;
4653 }
4654 else if (eNodeSocketInOut(fromsock.in_out) == SOCK_IN &&
4655 eNodeSocketInOut(tosock.in_out) == SOCK_OUT)
4656 {
4657 /* OK but flip */
4658 link = MEM_new<bNodeLink>(__func__);
4659 BLI_addtail(&ntree.links, link);
4660 link->fromnode = &tonode;
4661 link->fromsock = &tosock;
4662 link->tonode = &fromnode;
4663 link->tosock = &fromsock;
4664 }
4665
4666 BKE_ntree_update_tag_link_added(&ntree, link);
4667 BLI_assert(link);
4668
4669 if (link->tosock->is_multi_input()) {
4670 link->multi_input_sort_id = node_count_links(&ntree, link->tosock) - 1;
4671 }
4672
4673 return *link;
4674}
4675
4677{
4678 /* Can be called for links outside a node tree (e.g. clipboard). */
4679 if (ntree) {
4680 BLI_remlink(&ntree->links, &link);
4681 }
4682
4683 if (link.tosock) {
4684 link.tosock->link = nullptr;
4685 }
4686 MEM_delete(&link);
4687
4688 if (ntree) {
4690 }
4691}
4692
4693void node_link_set_mute(bNodeTree &ntree, bNodeLink &link, const bool muted)
4694{
4695 const bool was_muted = link.is_muted();
4697 if (muted != was_muted) {
4698 BKE_ntree_update_tag_link_mute(&ntree, &link);
4699 }
4700}
4701
4703{
4704 for (bNodeLink &link : ntree.links.items_mutable()) {
4705 if (link.fromsock == &sock || link.tosock == &sock) {
4706 node_remove_link(&ntree, link);
4707 }
4708 }
4709}
4710
4712{
4713 return !(link.fromsock->is_visible() && link.tosock->is_visible());
4714}
4715
4716static bool check_link_selected_backward(const bNodeLink &link, Set<const bNode *> &visited_nodes)
4717{
4718 const bNode *node = link.fromnode;
4719 if (!node) {
4720 return false;
4721 }
4722 if (node->is_selected()) {
4723 return true;
4724 }
4725 if (!node->is_reroute()) {
4726 return false;
4727 }
4728 if (!visited_nodes.add(node)) {
4729 return false;
4730 }
4731 if (node->input_sockets().is_empty()) {
4732 return false;
4733 }
4734 const bNodeSocket &input_socket = node->input_socket(0);
4735 for (const bNodeLink *prev_link : input_socket.directly_linked_links()) {
4736 if (check_link_selected_backward(*prev_link, visited_nodes)) {
4737 return true;
4738 }
4739 }
4740 return false;
4741}
4742
4743static bool check_link_selected_forward(const bNodeLink &link, Set<const bNode *> &visited_nodes)
4744{
4745 const bNode *node = link.tonode;
4746 if (!node) {
4747 return false;
4748 }
4749 if (node->is_selected()) {
4750 return true;
4751 }
4752 if (!node->is_reroute()) {
4753 return false;
4754 }
4755 if (!visited_nodes.add(node)) {
4756 return false;
4757 }
4758 if (node->output_sockets().is_empty()) {
4759 return false;
4760 }
4761 const bNodeSocket &output_socket = node->output_socket(0);
4762 for (const bNodeLink *next_link : output_socket.directly_linked_links()) {
4763 if (check_link_selected_forward(*next_link, visited_nodes)) {
4764 return true;
4765 }
4766 }
4767 return false;
4768}
4769
4771{
4772 if (link.fromnode->is_selected() || link.tonode->is_selected()) {
4773 return true;
4774 }
4775 if (!link.fromnode->is_reroute() && !link.tonode->is_reroute()) {
4776 return false;
4777 }
4778
4780
4781 if (link.fromnode->is_reroute()) {
4782 Set<const bNode *> visited_backward;
4783 if (check_link_selected_backward(link, visited_backward)) {
4784 return true;
4785 }
4786 }
4787 if (link.tonode->is_reroute()) {
4788 Set<const bNode *> visited_forward;
4789 if (check_link_selected_forward(link, visited_forward)) {
4790 return true;
4791 }
4792 }
4793 return false;
4794}
4795
4796/* Adjust the indices of links connected to the given multi input socket after deleting the link at
4797 * `deleted_index`. This function also works if the link has not yet been deleted. */
4799 const bNodeSocket *sock,
4800 const int deleted_index)
4801{
4802 for (bNodeLink &link : ntree->links) {
4803 /* We only need to adjust those with a greater index, because the others will have the same
4804 * index. */
4805 if (link.tosock != sock || link.multi_input_sort_id <= deleted_index) {
4806 continue;
4807 }
4808 link.multi_input_sort_id -= 1;
4809 }
4810}
4811
4813{
4814 Vector<bNodeLink *> duplicate_links_to_remove;
4815
4816 /* redirect downstream links */
4817 for (bNodeLink &link : ntree.links.items_mutable()) {
4818 /* do we have internal link? */
4819 if (link.fromnode != &node) {
4820 continue;
4821 }
4822
4823 const bNodeSocket *internal_input = nullptr;
4824 for (const bNodeInternalLink &internal_link : node.runtime->internal_links) {
4825 if (internal_link.out == link.fromsock) {
4826 internal_input = internal_link.in;
4827 break;
4828 }
4829 }
4830 bNodeLink *fromlink = internal_input ? internal_input->link : nullptr;
4831
4832 if (fromlink == nullptr) {
4833 if (link.tosock->is_multi_input()) {
4835 &ntree, link.tosock, link.multi_input_sort_id);
4836 }
4837 node_remove_link(&ntree, link);
4838 continue;
4839 }
4840
4841 if (link.tosock->is_multi_input()) {
4842 /* remove the link that would be the same as the relinked one */
4843 for (bNodeLink &link_to_compare : ntree.links.items_mutable()) {
4844 if (link_to_compare.fromsock == fromlink->fromsock &&
4845 link_to_compare.tosock == link.tosock)
4846 {
4848 &ntree, link_to_compare.tosock, link_to_compare.multi_input_sort_id);
4849 duplicate_links_to_remove.append_non_duplicates(&link_to_compare);
4850 }
4851 }
4852 }
4853
4854 link.fromnode = fromlink->fromnode;
4855 link.fromsock = fromlink->fromsock;
4856
4857 /* if the up- or downstream link is invalid,
4858 * the replacement link will be invalid too.
4859 */
4860 if (!(fromlink->flag & NODE_LINK_VALID)) {
4861 link.flag &= ~NODE_LINK_VALID;
4862 }
4863
4864 if (fromlink->flag & NODE_LINK_MUTED) {
4865 link.flag |= NODE_LINK_MUTED;
4866 }
4867
4869 }
4870
4871 for (bNodeLink *link : duplicate_links_to_remove) {
4872 node_remove_link(&ntree, *link);
4873 }
4874
4875 /* remove remaining upstream links */
4876 for (bNodeLink &link : ntree.links.items_mutable()) {
4877 if (link.tonode == &node) {
4878 node_remove_link(&ntree, link);
4879 }
4880 }
4881}
4882
4884{
4885 BLI_assert(parent.is_frame());
4887 node.parent = &parent;
4889}
4890
4892{
4893 if (node.parent) {
4894 BLI_assert(node.parent->is_frame());
4895 node.parent = nullptr;
4897 }
4898}
4899
4901 const bNode &to_node,
4902 const bNodeSocket *from_sock,
4903 const bNodeSocket &to_sock)
4904{
4905 float offset_x;
4906 int tot_sock_idx;
4907
4908 /* Socket to plug into. */
4909 if (eNodeSocketInOut(to_sock.in_out) == SOCK_IN) {
4910 offset_x = -(from_node.typeinfo->default_width + 50);
4911 tot_sock_idx = to_node.outputs.count();
4912 tot_sock_idx += BLI_findindex(&to_node.inputs, &to_sock);
4913 }
4914 else {
4915 offset_x = to_node.typeinfo->default_width + 50;
4916 tot_sock_idx = BLI_findindex(&to_node.outputs, &to_sock);
4917 }
4918
4919 BLI_assert(tot_sock_idx != -1);
4920
4921 float offset_y = U.widget_unit * tot_sock_idx;
4922
4923 /* Output socket. */
4924 if (from_sock) {
4925 if (eNodeSocketInOut(from_sock->in_out) == SOCK_IN) {
4926 tot_sock_idx = from_node.outputs.count();
4927 tot_sock_idx += BLI_findindex(&from_node.inputs, from_sock);
4928 }
4929 else {
4930 tot_sock_idx = BLI_findindex(&from_node.outputs, from_sock);
4931 }
4932 }
4933
4934 BLI_assert(tot_sock_idx != -1);
4935
4936 offset_y -= U.widget_unit * tot_sock_idx;
4937
4938 from_node.location[0] = to_node.location[0] + offset_x;
4939 from_node.location[1] = to_node.location[1] - offset_y;
4940}
4941
4943{
4944 for (bNodeSocket &socket : node.inputs) {
4945 if (socket.link != nullptr) {
4946 bNodeLink *link = socket.link;
4947 node_position_relative(*link->fromnode, *link->tonode, link->fromsock, *link->tosock);
4949 }
4950 }
4951}
4952
4954 std::optional<Library *> owner_library,
4955 ID *owner_id,
4956 const bool is_embedded,
4957 const StringRef name,
4958 const StringRef idname)
4959{
4960 /* trees are created as local trees for material or texture nodes,
4961 * node groups and other tree types are created as library data.
4962 */
4963 int flag = 0;
4964 if (is_embedded || bmain == nullptr) {
4966 }
4967 BLI_assert_msg(!owner_library || !owner_id,
4968 "Embedded NTrees should never have a defined owner library here");
4969 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(
4970 BKE_libblock_alloc_in_lib(bmain, owner_library, ID_NT, std::string(name).c_str(), flag));
4971 BKE_libblock_init_empty(&ntree->id);
4972 if (is_embedded) {
4973 BLI_assert(owner_id != nullptr);
4974 ntree->id.flag |= ID_FLAG_EMBEDDED_DATA;
4975 ntree->owner_id = owner_id;
4976 bNodeTree **ntree_owner_ptr = node_tree_ptr_from_id(owner_id);
4977 BLI_assert(ntree_owner_ptr != nullptr);
4978 *ntree_owner_ptr = ntree;
4979 ntree->id.lib = owner_id->lib;
4980 ntree->id.tag |= owner_id->tag & int(ID_TAG_EXTERN | ID_TAG_INDIRECT);
4981 }
4982 else {
4983 BLI_assert(owner_id == nullptr);
4984 }
4985
4986 idname.copy_utf8_truncated(ntree->idname);
4988
4989 return ntree;
4990}
4991
4992bNodeTree *node_tree_add_tree(Main *bmain, const StringRef name, const StringRef idname)
4993{
4994 return node_tree_add_tree_do(bmain, std::nullopt, nullptr, false, name, idname);
4995}
4996
4998 Library *owner_library,
4999 const StringRefNull name,
5000 const StringRefNull idname)
5001{
5002 return node_tree_add_tree_do(bmain, owner_library, nullptr, false, name, idname);
5003}
5004
5006 ID *owner_id,
5007 const StringRefNull name,
5008 const StringRefNull idname)
5009{
5010 return node_tree_add_tree_do(nullptr, std::nullopt, owner_id, true, name, idname);
5011}
5012
5013bNodeTree *node_tree_copy_tree_ex(const bNodeTree &ntree, Main *bmain, const bool do_id_user)
5014{
5015 const int flag = do_id_user ? 0 : LIB_ID_CREATE_NO_USER_REFCOUNT | LIB_ID_CREATE_NO_MAIN;
5016
5017 bNodeTree *ntree_copy = reinterpret_cast<bNodeTree *>(
5018 BKE_id_copy_ex(bmain, reinterpret_cast<const ID *>(&ntree), nullptr, flag));
5019 return ntree_copy;
5020}
5022{
5023 return node_tree_copy_tree_ex(ntree, bmain, true);
5024}
5025
5027{
5028 for (bNodeLink &link : ntree.links.items_mutable()) {
5029 ListBaseT<bNodeSocket> *lb = nullptr;
5030 if (link.fromnode == &node) {
5031 lb = &node.outputs;
5032 }
5033 else if (link.tonode == &node) {
5034 lb = &node.inputs;
5035 }
5036
5037 if (lb) {
5038 /* Only bother adjusting if the socket is not on the node we're deleting. */
5039 if (link.tonode != &node && link.tosock->is_multi_input()) {
5041 &ntree, link.tosock, link.multi_input_sort_id);
5042 }
5043 for (const bNodeSocket &sock : *lb) {
5044 if (link.fromsock == &sock || link.tosock == &sock) {
5045 node_remove_link(&ntree, link);
5046 break;
5047 }
5048 }
5049 }
5050 }
5051}
5052
5053void node_unlink_attached(bNodeTree *ntree, const bNode *parent)
5054{
5055 for (bNode *node : ntree->all_nodes()) {
5056 if (node->parent == parent) {
5057 node_detach_node(*ntree, *node);
5058 }
5059 }
5060}
5061
5063{
5064 /* Rebuild nodes #VectorSet which must have the same order as the list. */
5065 node_tree.runtime->nodes_by_id.clear();
5066
5067 for (const auto [i, node] : node_tree.nodes.enumerate()) {
5068 node_tree.runtime->nodes_by_id.add_new(&node);
5069 node.runtime->index_in_tree = i;
5070 }
5071}
5072
5074{
5075 /* since it is called while free database, node->id is undefined */
5076
5077 /* can be called for nodes outside a node tree (e.g. clipboard) */
5078 if (ntree) {
5079 BLI_remlink(&ntree->nodes, &node);
5080
5081 const bool was_last = ntree->runtime->nodes_by_id.as_span().last() == &node;
5082 if (was_last) {
5083 /* No need to rebuild the entire bNodeTreeRuntime::nodes_by_id when the removed node is the
5084 * last one. */
5085 ntree->runtime->nodes_by_id.pop();
5086 }
5087 else {
5088 /* Rebuild nodes #VectorSet which must have the same order as the list. */
5089 node_rebuild_id_vector(*ntree);
5090 }
5091
5092 /* texture node has bad habit of keeping exec data around */
5093 if (ntree->type == NTREE_TEXTURE && ntree->runtime->execdata) {
5095 ntree->runtime->execdata = nullptr;
5096 }
5097 }
5098
5099 if (node.typeinfo && node.typeinfo->freefunc) {
5100 node.typeinfo->freefunc(&node);
5101 }
5102
5103 for (bNodeSocket &sock : node.inputs.items_mutable()) {
5104 /* Remember, no ID user refcount management here! */
5105 node_socket_free(&sock, false);
5106 MEM_delete(&sock);
5107 }
5108 for (bNodeSocket &sock : node.outputs.items_mutable()) {
5109 /* Remember, no ID user refcount management here! */
5110 node_socket_free(&sock, false);
5111 MEM_delete(&sock);
5112 }
5113
5114 MEM_SAFE_DELETE(node.panel_states_array);
5115
5116 if (node.prop) {
5117 /* Remember, no ID user refcount management here! */
5118 IDP_FreeProperty_ex(node.prop, false);
5119 }
5120 if (node.system_properties) {
5121 /* Remember, no ID user refcount management here! */
5122 IDP_FreeProperty_ex(node.system_properties, false);
5123 }
5124
5125 if (node.runtime->declaration) {
5126 /* Only free if this declaration is not shared with the node type, which can happen if it does
5127 * not depend on any context. */
5128 if (!node.typeinfo || node.runtime->declaration != node.typeinfo->static_declaration) {
5129 delete node.runtime->declaration;
5130 }
5131 }
5132
5133 MEM_delete(node.runtime);
5134 MEM_delete(&node);
5135
5136 if (ntree) {
5138 }
5139}
5140
5142{
5143 /* For removing nodes while editing localized node trees. */
5144 BLI_assert((ntree.id.tag & ID_TAG_LOCALIZED) != 0);
5145
5146 /* These two lines assume the caller might want to free a single node and maintain
5147 * a valid state in the node tree. */
5148 node_unlink_node(ntree, node);
5149 node_unlink_attached(&ntree, &node);
5150
5151 node_free_node(&ntree, node);
5153}
5154
5156 Main *bmain, bNodeTree &ntree, bNode &node, const bool do_id_user, const bool remove_animation)
5157{
5158 /* This function is not for localized node trees, we do not want
5159 * do to ID user reference-counting and removal of animation data then. */
5160 BLI_assert((ntree.id.tag & ID_TAG_LOCALIZED) == 0);
5161
5162 if (do_id_user) {
5163 /* Free callback for NodeCustomGroup. */
5164 if (node.typeinfo->freefunc_api) {
5165 PointerRNA ptr = RNA_pointer_create_discrete(&ntree.id, RNA_Node, &node);
5166
5167 node.typeinfo->freefunc_api(&ptr);
5168 }
5169
5170 /* Do user counting. */
5171 if (node.id) {
5172 id_us_min(node.id);
5173 }
5174
5175 for (bNodeSocket &sock : node.inputs) {
5177 }
5178 for (bNodeSocket &sock : node.outputs) {
5180 }
5181 }
5182
5183 if (remove_animation) {
5184 char propname_esc[MAX_IDPROP_NAME * 2];
5185 char prefix[MAX_IDPROP_NAME * 2];
5186
5187 BLI_str_escape(propname_esc, node.name, sizeof(propname_esc));
5188 SNPRINTF_UTF8(prefix, "nodes[\"%s\"]", propname_esc);
5189
5190 if (BKE_animdata_fix_paths_remove(&ntree.id, prefix)) {
5191 if (bmain != nullptr) {
5193 }
5194 }
5195 }
5196
5197 node_unlink_node(ntree, node);
5198 node_unlink_attached(&ntree, &node);
5199
5200 /* Free node itself. */
5201 node_free_node(&ntree, node);
5203}
5204
5206{
5207 /* Only localized node trees store a copy for each node group tree.
5208 * Each node group tree in a localized node tree can be freed,
5209 * since it is a localized copy itself (no risk of accessing freed
5210 * data in main, see #37939). */
5211 if (!(ntree->id.tag & ID_TAG_LOCALIZED)) {
5212 return;
5213 }
5214
5215 for (bNode &node : ntree->nodes) {
5216 bNodeTree *ngroup = reinterpret_cast<bNodeTree *>(node.id);
5217 if (node.is_group() && ngroup != nullptr) {
5218 node_tree_free_tree(*ngroup);
5219 MEM_delete(ngroup);
5220 }
5221 }
5222}
5223
5225{
5226 ntree_free_data(&ntree.id);
5227 BKE_animdata_free(&ntree.id, false);
5229}
5230
5232{
5233 node_tree_free_tree(*ntree);
5234 BKE_libblock_free_data(&ntree->id, true);
5236}
5237
5239{
5240 const bool is_compositor = ntree.type == NTREE_COMPOSIT;
5241 const bool is_geometry = ntree.type == NTREE_GEOMETRY;
5242 /* find the active outputs, might become tree type dependent handler */
5243 for (bNode &node : ntree.nodes) {
5244 if (node.typeinfo->nclass == NODE_CLASS_OUTPUT) {
5245 /* we need a check for which output node should be tagged like this, below an exception */
5246 if (node.is_type("CompositorNodeOutputFile"_ustr)) {
5247 continue;
5248 }
5249 const bool node_is_output = node.is_type("CompositorNodeViewer"_ustr) ||
5250 node.is_type("GeometryNodeViewer"_ustr);
5251
5252 int output = 0;
5253 /* there is more types having output class, each one is checked */
5254
5255 for (bNode &tnode : ntree.nodes) {
5256 if (tnode.typeinfo->nclass != NODE_CLASS_OUTPUT) {
5257 continue;
5258 }
5259
5260 /* same type, exception for viewer */
5261 const bool tnode_is_output = tnode.is_type("CompositorNodeViewer"_ustr) ||
5262 tnode.is_type("GeometryNodeViewer"_ustr);
5263 const bool viewer_case = (is_compositor || is_geometry) && tnode_is_output &&
5264 node_is_output;
5265 const bool has_same_shortcut = viewer_case && &node != &tnode &&
5266 tnode.custom1 == node.custom1 &&
5268
5269 if (tnode.type_legacy == node.type_legacy || viewer_case) {
5270 if (tnode.flag & NODE_DO_OUTPUT) {
5271 output++;
5272 if (output > 1) {
5273 tnode.flag &= ~NODE_DO_OUTPUT;
5274 }
5275 }
5276 }
5277 if (has_same_shortcut) {
5279 }
5280 }
5281
5282 /* Only geometry nodes is allowed to have no active output in the node tree. */
5283 if (output == 0 && !is_geometry) {
5284 node.flag |= NODE_DO_OUTPUT;
5285 }
5286 }
5287
5288 /* group node outputs use this flag too */
5289 if (node.is_group_output()) {
5290 int output = 0;
5291 for (bNode &tnode : ntree.nodes) {
5292 if (!tnode.is_group_output()) {
5293 continue;
5294 }
5295 if (tnode.flag & NODE_DO_OUTPUT) {
5296 output++;
5297 if (output > 1) {
5298 tnode.flag &= ~NODE_DO_OUTPUT;
5299 }
5300 }
5301 }
5302 if (output == 0) {
5303 node.flag |= NODE_DO_OUTPUT;
5304 }
5305 }
5306 }
5307
5308 /* here we could recursively set which nodes have to be done,
5309 * might be different for editor or for "real" use... */
5310}
5311
5313{
5314 /* If this is ever extended such that a non-animatable ID type can embed a node
5315 * tree, update animrig::internal::rebuild_slot_user_cache(). That
5316 * function assumes that node trees can only be embedded by animatable IDs. */
5317
5318 switch (id->id_type()) {
5319 case ID_MA:
5320 return &reinterpret_cast<Material *>(id)->nodetree;
5321 case ID_LA:
5322 return &reinterpret_cast<Light *>(id)->nodetree;
5323 case ID_WO:
5324 return &reinterpret_cast<World *>(id)->nodetree;
5325 case ID_TE:
5326 return &reinterpret_cast<Tex *>(id)->nodetree;
5327 case ID_SCE:
5328 /* Needed for backward compatibility. */
5329 return &reinterpret_cast<Scene *>(id)->nodetree;
5330 case ID_LS:
5331 return &reinterpret_cast<FreestyleLineStyle *>(id)->nodetree;
5332 default:
5333 return nullptr;
5334 }
5335}
5336
5338{
5339 bNodeTree **nodetree = node_tree_ptr_from_id(id);
5340 return (nodetree != nullptr) ? *nodetree : nullptr;
5341}
5342
5343void node_tree_node_flag_set(bNodeTree &ntree, const eNode_Flag flag, const bool enable)
5344{
5345 for (bNode *node : ntree.all_nodes()) {
5346 if (enable) {
5347 node->flag |= flag;
5348 }
5349 else {
5350 node->flag &= ~flag;
5351 }
5352 }
5353}
5354
5355bNodeTree *node_tree_localize(bNodeTree *ntree, std::optional<ID *> new_owner_id)
5356{
5357 if (ntree == nullptr) {
5358 return nullptr;
5359 }
5360
5361 /* Make full copy outside of Main database.
5362 * NOTE: previews are not copied here. */
5363 bNodeTree *ltree = reinterpret_cast<bNodeTree *>(
5364 BKE_id_copy_in_lib(nullptr,
5365 std::nullopt,
5366 &ntree->id,
5367 new_owner_id,
5368 nullptr,
5370
5371 ltree->id.tag |= ID_TAG_LOCALIZED;
5372
5373 for (bNode &node : ltree->nodes) {
5374 bNodeTree *group = reinterpret_cast<bNodeTree *>(node.id);
5375 if (node.is_group() && group != nullptr) {
5376 node.id = reinterpret_cast<ID *>(node_tree_localize(group, nullptr));
5377 }
5378 }
5379
5380 /* Ensures only a single output node is enabled. */
5381 node_tree_set_output(*ntree);
5382
5383 bNode *node_src = ntree->nodes.first();
5384 bNode *node_local = ltree->nodes.first();
5385 while (node_src != nullptr) {
5386 node_local->runtime->original = node_src;
5387 node_src = node_src->next;
5388 node_local = node_local->next;
5389 }
5390
5391 if (ntree->typeinfo->localize) {
5392 ntree->typeinfo->localize(ltree, ntree);
5393 }
5394
5395 return ltree;
5396}
5397
5398static bool ntree_contains_tree_exec(const bNodeTree &tree_to_search_in,
5399 const bNodeTree &tree_to_search_for,
5400 Set<const bNodeTree *> &already_passed)
5401{
5402 if (&tree_to_search_in == &tree_to_search_for) {
5403 return true;
5404 }
5405
5406 tree_to_search_in.ensure_topology_cache();
5407 for (const bNode *node_group : tree_to_search_in.group_nodes()) {
5408 const bNodeTree *sub_tree_search_in = reinterpret_cast<const bNodeTree *>(node_group->id);
5409 if (!sub_tree_search_in) {
5410 continue;
5411 }
5412 if (!already_passed.add(sub_tree_search_in)) {
5413 continue;
5414 }
5415 if (ntree_contains_tree_exec(*sub_tree_search_in, tree_to_search_for, already_passed)) {
5416 return true;
5417 }
5418 }
5419
5420 return false;
5421}
5422
5423bool node_tree_contains_tree(const bNodeTree &tree_to_search_in,
5424 const bNodeTree &tree_to_search_for)
5425{
5426 if (&tree_to_search_in == &tree_to_search_for) {
5427 return true;
5428 }
5429
5430 Set<const bNodeTree *> already_passed;
5431 return ntree_contains_tree_exec(tree_to_search_in, tree_to_search_for, already_passed);
5432}
5433
5434int node_count_socket_links(const bNodeTree &ntree, const bNodeSocket &sock)
5435{
5436 int tot = 0;
5437 for (const bNodeLink &link : ntree.links) {
5438 if (link.fromsock == &sock || link.tosock == &sock) {
5439 tot++;
5440 }
5441 }
5442 return tot;
5443}
5444
5446{
5447 for (bNode *node : ntree.all_nodes()) {
5448 if (node->flag & NODE_ACTIVE) {
5449 return node;
5450 }
5451 }
5452 return nullptr;
5453}
5454
5456{
5457 bool changed = false;
5458 if (select != node.is_selected()) {
5459 changed = true;
5461 }
5462 if (select) {
5463 return changed;
5464 }
5465 /* Deselect sockets too. */
5466 for (bNodeSocket &sock : node.inputs) {
5467 changed |= (sock.flag & SOCK_SELECT) != 0;
5468 sock.flag &= ~SOCK_SELECT;
5469 }
5470 for (bNodeSocket &sock : node.outputs) {
5471 changed |= (sock.flag & SOCK_SELECT) != 0;
5472 sock.flag &= ~SOCK_SELECT;
5473 }
5474 return changed;
5475}
5476
5478{
5479 for (bNode *node : ntree.all_nodes()) {
5480 node->flag &= ~NODE_ACTIVE;
5481 }
5482}
5483
5485{
5486 const bool is_paint_canvas = node_supports_active_flag(node, NODE_ACTIVE_PAINT_CANVAS);
5487 const bool is_texture_class = node_supports_active_flag(node, NODE_ACTIVE_TEXTURE);
5488 eNode_Flag flags_to_set = NODE_ACTIVE;
5489 SET_FLAG_FROM_TEST(flags_to_set, is_paint_canvas, NODE_ACTIVE_PAINT_CANVAS);
5490 SET_FLAG_FROM_TEST(flags_to_set, is_texture_class, NODE_ACTIVE_TEXTURE);
5491
5492 /* Make sure only one node is active per node tree. */
5493 for (bNode *tnode : ntree.all_nodes()) {
5494 tnode->flag &= ~flags_to_set;
5495 }
5496 node.flag |= flags_to_set;
5497}
5498
5499void node_set_socket_availability(bNodeTree &ntree, bNodeSocket &sock, const bool is_available)
5500{
5501 if (is_available == sock.is_available()) {
5502 return;
5503 }
5504 if (is_available) {
5505 sock.flag &= ~SOCK_UNAVAIL;
5506 }
5507 else {
5508 sock.flag |= SOCK_UNAVAIL;
5509 }
5511}
5512
5514{
5515 if (sock.is_multi_input()) {
5516 return 4095;
5517 }
5518 if (sock.typeinfo == nullptr) {
5519 return sock.limit;
5520 }
5521 const bNodeSocketType &stype = *sock.typeinfo;
5522 if (!stype.use_link_limits_of_type) {
5523 return sock.limit;
5524 }
5525 return eNodeSocketInOut(sock.in_out) == SOCK_IN ? stype.input_link_limit :
5526 stype.output_link_limit;
5527}
5528
5529static void update_socket_declarations(ListBaseT<bNodeSocket> *sockets,
5530 const Span<SocketDeclaration *> declarations)
5531{
5532
5533 for (const auto [index, socket] : (sockets)->enumerate()) {
5534 const SocketDeclaration &socket_decl = *declarations[index];
5535 socket.runtime->declaration = &socket_decl;
5536 }
5537}
5538
5539static void reset_socket_declarations(ListBaseT<bNodeSocket> *sockets)
5540{
5541 for (bNodeSocket &socket : *sockets) {
5542 socket.runtime->declaration = nullptr;
5543 }
5544}
5545
5547{
5548 BLI_assert(node->runtime->declaration != nullptr);
5549 if (node->runtime->declaration->skip_updating_sockets) {
5552 return;
5553 }
5554 update_socket_declarations(&node->inputs, node->runtime->declaration->inputs.as_span());
5555 update_socket_declarations(&node->outputs, node->runtime->declaration->outputs.as_span());
5556}
5557
5559{
5560 if (node.runtime->declaration != nullptr) {
5561 return false;
5562 }
5563 if (node.typeinfo->declare) {
5564 if (node.typeinfo->static_declaration) {
5565 if (!node.typeinfo->static_declaration->is_context_dependent) {
5566 node.runtime->declaration = node.typeinfo->static_declaration;
5567 return true;
5568 }
5569 }
5570 }
5571 if (node.typeinfo->declare) {
5573 return true;
5574 }
5575 return false;
5576}
5577
5579{
5582 return true;
5583 }
5584 return false;
5585}
5586
5588{
5589 return float2(node.runtime->draw_bounds.xmax, node.runtime->draw_bounds.ymax) -
5590 float2(node.runtime->draw_bounds.xmin, node.runtime->draw_bounds.ymin);
5591}
5592
5594{
5595 node.runtime->update |= NODE_UPDATE_ID;
5596}
5597
5598/* Node Instance Hash */
5599
5602
5603/* Generate a hash key from ntree and node names
5604 * Uses the djb2 algorithm with xor by Bernstein:
5605 * http://www.cse.yorku.ca/~oz/hash.html
5606 */
5608{
5609 char c;
5610
5611 while ((c = *str++)) {
5612 hash.value = ((hash.value << 5) + hash.value) ^ c; /* (hash * 33) ^ c */
5613 }
5614
5615 /* separator '\0' character, to avoid ambiguity from concatenated strings */
5616 hash.value = (hash.value << 5) + hash.value; /* hash * 33 */
5617
5618 return hash;
5619}
5620
5622 const bNodeTree *ntree,
5623 const bNode *node)
5624{
5625 bNodeInstanceKey key = node_hash_int_str(parent_key, ntree->id.name + 2);
5626
5627 if (node) {
5628 key = node_hash_int_str(key, node->name);
5629 }
5630
5631 return key;
5632}
5633
5634/* Build a set of built-in node types to check for known types. */
5636{
5638 for (const bNodeType *ntype : node_types_get()) {
5639 result.add(ntype->type_legacy);
5640 }
5641 return result;
5642}
5643
5644static bool can_read_node_type(const bNode &node)
5645{
5646 /* Can always read custom node types. */
5647 if (ELEM(node.type_legacy, NODE_CUSTOM, NODE_CUSTOM_GROUP)) {
5648 return true;
5649 }
5650 const UString idname(node.idname);
5651 /* Nodes that require storage but don't have any storage data are invalid. */
5652 if (node.storage == nullptr) {
5653 const bNodeType *node_type = node_type_find(idname);
5654 if (!node_type || !node_type->storagename.empty()) {
5655 return false;
5656 }
5657 }
5658 if (node.type_legacy < NODE_LEGACY_TYPE_GENERATION_START) {
5659 /* Check known built-in types. */
5660 static Set<int> known_types = get_known_node_types_set();
5661 return known_types.contains(node.type_legacy);
5662 }
5663 /* Nodes with larger legacy_type are only identified by their idname. */
5664 return node_type_find(idname) != nullptr;
5665}
5666
5668{
5669 node.type_legacy = NODE_CUSTOM;
5670 /* This type name is arbitrary, it just has to be unique enough to not match a future node
5671 * idname. Includes the old type identifier for debugging purposes. */
5672 const std::string old_idname = node.idname;
5673 SNPRINTF_UTF8(node.idname, "Undefined[%s]", old_idname.c_str());
5674 node.typeinfo = &NodeTypeUndefined;
5675}
5676
5678{
5679 /* Replace unknown node types with "Undefined".
5680 * This happens when loading files from newer Blender versions. Such nodes cannot be read
5681 * reliably so replace the idname with an undefined type. This keeps links and socket names but
5682 * discards storage and other type-specific data.
5683 *
5684 * Replacement has to happen after after-liblink-versioning, since some node types still get
5685 * replaced in those late versioning steps. */
5686 FOREACH_NODETREE_BEGIN (&main, ntree, owner_id) {
5687 for (bNode *node : ntree->all_nodes()) {
5688 /* If the node type is built-in but unknown, the node cannot be read. */
5689 if (!can_read_node_type(*node)) {
5691 }
5692 }
5693 }
5695 /* Update all new node trees on file read or append, to add/remove sockets
5696 * in groups nodes if the group changed, and handle any update flags that
5697 * might have been set in file reading or versioning. */
5698 FOREACH_NODETREE_BEGIN (&main, ntree, owner_id) {
5699 if (owner_id->tag & ID_TAG_NEW) {
5701 }
5702 }
5705}
5706
5708{
5709 if (id == nullptr) {
5710 return;
5711 }
5712
5713 bool need_update = false;
5714
5715 /* Update all users of ngroup, to add/remove sockets as needed. */
5716 FOREACH_NODETREE_BEGIN (main, ntree, owner_id) {
5717 for (bNode *node : ntree->all_nodes()) {
5718 if (node->id == id) {
5720 need_update = true;
5721 }
5722 }
5723 }
5725 if (need_update) {
5727 }
5728}
5729
5730/* ************* node type access ********** */
5731
5732std::string node_label(const bNodeTree &ntree, const bNode &node)
5733{
5734 if (node.label[0] != '\0') {
5735 return node.label;
5736 }
5737
5738 if (node.typeinfo->labelfunc) {
5739 char label_buffer[MAX_NAME];
5740 node.typeinfo->labelfunc(&ntree, &node, label_buffer, MAX_NAME);
5741 return label_buffer;
5742 }
5743
5744 return IFACE_(node.typeinfo->ui_name);
5745}
5746
5747std::optional<StringRefNull> node_socket_short_label(const bNodeSocket &sock)
5748{
5749 if (sock.runtime->declaration != nullptr) {
5750 const UString short_label = sock.runtime->declaration->short_label;
5751 if (!short_label.is_empty()) {
5752 return short_label.ref();
5753 }
5754 }
5755 return std::nullopt;
5756}
5757
5759{
5760 /* The node is not explicitly defined. */
5761 if (sock.runtime->declaration == nullptr) {
5762 return (sock.label[0] != '\0') ? sock.label : sock.name;
5763 }
5764 if (sock.runtime->declaration->label_fn) {
5765 return (*sock.runtime->declaration->label_fn)(sock.owner_node());
5766 }
5767 return sock.name;
5768}
5769
5771{
5772 /* The node is not explicitly defined. */
5773 if (sock.runtime->declaration == nullptr) {
5774 return nullptr;
5775 }
5776
5777 const std::optional<std::string> &translation_context =
5779
5780 /* Default context. */
5781 if (!translation_context.has_value()) {
5782 return nullptr;
5783 }
5784
5785 return translation_context->c_str();
5786}
5787
5789{
5790 const int nclass = node.typeinfo->ui_class == nullptr ? node.typeinfo->nclass :
5791 node.typeinfo->ui_class(&node);
5792 switch (nclass) {
5793 case NODE_CLASS_INPUT:
5794 return NodeColorTag::Input;
5795 case NODE_CLASS_OUTPUT:
5796 return NodeColorTag::Output;
5798 return NodeColorTag::Color;
5800 return NodeColorTag::Vector;
5802 return NodeColorTag::Filter;
5805 case NODE_CLASS_MATTE:
5806 return NodeColorTag::Matte;
5807 case NODE_CLASS_DISTORT:
5808 return NodeColorTag::Distort;
5809 case NODE_CLASS_PATTERN:
5810 return NodeColorTag::Pattern;
5811 case NODE_CLASS_TEXTURE:
5812 return NodeColorTag::Texture;
5813 case NODE_CLASS_SCRIPT:
5814 return NodeColorTag::Script;
5817 case NODE_CLASS_SHADER:
5818 return NodeColorTag::Shader;
5823 case NODE_CLASS_GROUP:
5824 return NodeColorTag::Group;
5825 case NODE_CLASS_LAYOUT:
5826 break;
5827 }
5828 return NodeColorTag::None;
5829}
5830
5832{
5833 ntype.height = 100;
5834 ntype.minheight = 30;
5835 ntype.maxheight = FLT_MAX;
5836}
5837
5838/* allow this node for any tree type */
5839static bool node_poll_default(const bNodeType * /*ntype*/,
5840 const bNodeTree * /*ntree*/,
5841 const char ** /*r_disabled_hint*/)
5842{
5843 return true;
5844}
5845
5847 const bNodeTree *ntree,
5848 const char **r_disabled_hint)
5849{
5850 return node->typeinfo->poll(node->typeinfo, ntree, r_disabled_hint);
5851}
5852
5854{
5855 static std::atomic<int> next_legacy_type = []() {
5856 /* Randomize the value a bit to avoid accidentally depending on the generated legacy type to be
5857 * stable across Blender sessions. */
5860 }();
5861 const int new_type = next_legacy_type.fetch_add(1);
5862 BLI_assert(new_type <= std::numeric_limits<int16_t>::max());
5863 return new_type;
5864}
5865
5866void node_type_base(bNodeType &ntype, UString idname, std::optional<int16_t> legacy_type)
5867{
5868 ntype.idname = idname;
5869
5870 if (!legacy_type.has_value()) {
5871 /* Still auto-generate a legacy type for this node type if none was specified. This is
5872 * necessary because some code checks if two nodes are the same type by comparing their legacy
5873 * types. The exact value does not matter, but it must be unique. */
5874 legacy_type = get_next_auto_legacy_type();
5875 }
5876
5877 if (!ELEM(*legacy_type, NODE_CUSTOM, NODE_UNDEFINED)) {
5878 StructRNA *srna = RNA_struct_find(ntype.idname.c_str());
5879 BLI_assert(srna != nullptr);
5880 ntype.rna_ext.srna = srna;
5881 RNA_struct_blender_type_set(srna, &ntype);
5882 }
5883
5884 /* make sure we have a valid type (everything registered) */
5885 BLI_assert(ntype.idname[0] != '\0');
5886
5887 ntype.type_legacy = *legacy_type;
5889
5891
5892 ntype.poll = node_poll_default;
5894}
5895
5897 const StringRefNull idname,
5898 const StringRefNull name,
5899 const StringRefNull enum_name,
5900 const short nclass)
5901{
5902 ntype.idname = UString(idname);
5903 ntype.type_legacy = NODE_CUSTOM;
5904 ntype.ui_name = name;
5905 ntype.nclass = nclass;
5906 ntype.enum_name_legacy = enum_name.c_str();
5907
5909}
5910
5911std::optional<eCustomDataType> socket_type_to_custom_data_type(eNodeSocketDatatype type)
5912{
5913 switch (type) {
5914 case SOCK_FLOAT:
5915 return CD_PROP_FLOAT;
5916 case SOCK_VECTOR:
5917 return CD_PROP_FLOAT3;
5918 case SOCK_RGBA:
5919 return CD_PROP_COLOR;
5920 case SOCK_BOOLEAN:
5921 return CD_PROP_BOOL;
5922 case SOCK_ROTATION:
5923 return CD_PROP_QUATERNION;
5924 case SOCK_MATRIX:
5925 return CD_PROP_FLOAT4X4;
5926 case SOCK_INT:
5927 return CD_PROP_INT32;
5928 case SOCK_STRING:
5929 return CD_PROP_STRING;
5930 default:
5931 return std::nullopt;
5932 }
5933}
5934
5935std::optional<eNodeSocketDatatype> custom_data_type_to_socket_type(eCustomDataType type)
5936{
5937 switch (type) {
5938 case CD_PROP_FLOAT:
5939 return SOCK_FLOAT;
5940 case CD_PROP_INT8:
5941 return SOCK_INT;
5942 case CD_PROP_INT32:
5943 return SOCK_INT;
5944 case CD_PROP_FLOAT2:
5945 case CD_PROP_FLOAT3:
5946 case CD_PROP_FLOAT4:
5947 return SOCK_VECTOR;
5948 case CD_PROP_BOOL:
5949 return SOCK_BOOLEAN;
5950 case CD_PROP_COLOR:
5951 return SOCK_RGBA;
5952 case CD_PROP_BYTE_COLOR:
5953 return SOCK_RGBA;
5954 case CD_PROP_QUATERNION:
5955 return SOCK_ROTATION;
5956 case CD_PROP_FLOAT4X4:
5957 return SOCK_MATRIX;
5958 default:
5959 return std::nullopt;
5960 }
5961}
5962
5964{
5965 const bNodeSocketType *typeinfo = node_socket_type_find_static(type);
5966 return typeinfo->base_cpp_type;
5967}
5968
5970{
5971 const CPPType *cpp_type;
5972 switch (type) {
5973 case SOCK_FLOAT:
5974 cpp_type = &CPPType::get<float>();
5975 break;
5976 case SOCK_INT:
5977 cpp_type = &CPPType::get<int>();
5978 break;
5979 case SOCK_RGBA:
5980 cpp_type = &CPPType::get<ColorGeometry4f>();
5981 break;
5982 case SOCK_BOOLEAN:
5983 cpp_type = &CPPType::get<bool>();
5984 break;
5985 case SOCK_VECTOR:
5986 cpp_type = &CPPType::get<float3>();
5987 break;
5988 case SOCK_ROTATION:
5989 cpp_type = &CPPType::get<math::Quaternion>();
5990 break;
5991 case SOCK_MATRIX:
5992 cpp_type = &CPPType::get<float4x4>();
5993 break;
5994 case SOCK_BUNDLE:
5995 cpp_type = &CPPType::get<nodes::BundlePtr>();
5996 break;
5997 case SOCK_CLOSURE:
5998 cpp_type = &CPPType::get<nodes::ClosurePtr>();
5999 break;
6000 default:
6002 break;
6003 }
6005 return cpp_type;
6006}
6007
6008std::optional<eNodeSocketDatatype> geo_nodes_base_cpp_type_to_socket_type(const CPPType &type)
6009{
6010 if (type.is<float>()) {
6011 return SOCK_FLOAT;
6012 }
6013 if (type.is<int>()) {
6014 return SOCK_INT;
6015 }
6016 if (type.is_any<float2, float3, float4>()) {
6017 return SOCK_VECTOR;
6018 }
6019 if (type.is<ColorGeometry4f>()) {
6020 return SOCK_RGBA;
6021 }
6022 if (type.is<bool>()) {
6023 return SOCK_BOOLEAN;
6024 }
6025 if (type.is<math::Quaternion>()) {
6026 return SOCK_ROTATION;
6027 }
6028 if (type.is<nodes::MenuValue>()) {
6029 return SOCK_MENU;
6030 }
6031 if (type.is<float4x4>()) {
6032 return SOCK_MATRIX;
6033 }
6034 if (type.is<std::string>()) {
6035 return SOCK_STRING;
6036 }
6037 if (type.is<nodes::BundlePtr>()) {
6038 return SOCK_BUNDLE;
6039 }
6040 if (type.is<nodes::ClosurePtr>()) {
6041 return SOCK_CLOSURE;
6042 }
6043 if (type.is<GeometrySet>()) {
6044 return SOCK_GEOMETRY;
6045 }
6046 if (type.is<Material *>()) {
6047 return SOCK_MATERIAL;
6048 }
6049 if (type.is<Tex *>()) {
6050 return SOCK_TEXTURE;
6051 }
6052 if (type.is<Object *>()) {
6053 return SOCK_OBJECT;
6054 }
6055 if (type.is<Collection *>()) {
6056 return SOCK_COLLECTION;
6057 }
6058 if (type.is<Image *>()) {
6059 return SOCK_IMAGE;
6060 }
6061 if (type.is<VFont *>()) {
6062 return SOCK_FONT;
6063 }
6064 if (type.is<Scene *>()) {
6065 return SOCK_SCENE;
6066 }
6067 if (type.is<Text *>()) {
6068 return SOCK_TEXT_ID;
6069 }
6070 if (type.is<Mask *>()) {
6071 return SOCK_MASK;
6072 }
6073 if (type.is<bSound *>()) {
6074 return SOCK_SOUND;
6075 }
6076
6077 return std::nullopt;
6078}
6079
6080std::optional<VolumeGridType> socket_type_to_grid_type(const eNodeSocketDatatype type)
6081{
6082 switch (type) {
6083 case SOCK_BOOLEAN:
6084 return VOLUME_GRID_BOOLEAN;
6085 case SOCK_FLOAT:
6086 return VOLUME_GRID_FLOAT;
6087 case SOCK_INT:
6088 return VOLUME_GRID_INT;
6089 case SOCK_VECTOR:
6091 default:
6092 return std::nullopt;
6093 }
6094}
6095
6096std::optional<eNodeSocketDatatype> grid_type_to_socket_type(const VolumeGridType type)
6097{
6098 switch (type) {
6100 return SOCK_BOOLEAN;
6101 case VOLUME_GRID_FLOAT:
6102 return SOCK_FLOAT;
6103 case VOLUME_GRID_INT:
6104 return SOCK_INT;
6106 return SOCK_VECTOR;
6107 default:
6108 return std::nullopt;
6109 }
6110}
6111
6113 bNodeSocketTemplate *ntemp,
6114 const char defname[],
6115 const char delim)
6116{
6118 [&](const StringRef check_name) {
6119 for (bNodeSocketTemplate *ntemp_iter = list; ntemp_iter->type >= 0; ntemp_iter++) {
6120 if (ntemp_iter != ntemp) {
6121 if (ntemp_iter->identifier == check_name) {
6122 return true;
6123 }
6124 }
6125 }
6126 return false;
6127 },
6128 defname,
6129 delim,
6130 ntemp->identifier,
6131 sizeof(ntemp->identifier));
6132}
6133
6135 bNodeSocketTemplate *inputs,
6136 bNodeSocketTemplate *outputs)
6137{
6138 ntype->inputs = inputs;
6139 ntype->outputs = outputs;
6140
6141 /* automatically generate unique identifiers */
6142 if (inputs) {
6143 /* clear identifier strings (uninitialized memory) */
6144 for (bNodeSocketTemplate *ntemp = inputs; ntemp->type >= 0; ntemp++) {
6145 ntemp->identifier[0] = '\0';
6146 }
6147
6148 for (bNodeSocketTemplate *ntemp = inputs; ntemp->type >= 0; ntemp++) {
6149 STRNCPY(ntemp->identifier, ntemp->name);
6150 unique_socket_template_identifier(inputs, ntemp, ntemp->identifier, '_');
6151 }
6152 }
6153 if (outputs) {
6154 /* clear identifier strings (uninitialized memory) */
6155 for (bNodeSocketTemplate *ntemp = outputs; ntemp->type >= 0; ntemp++) {
6156 ntemp->identifier[0] = '\0';
6157 }
6158
6159 for (bNodeSocketTemplate *ntemp = outputs; ntemp->type >= 0; ntemp++) {
6160 STRNCPY(ntemp->identifier, ntemp->name);
6161 unique_socket_template_identifier(outputs, ntemp, ntemp->identifier, '_');
6162 }
6163 }
6164}
6165
6167 const std::optional<StringRefNull> storagename,
6168 void (*freefunc)(bNode *node),
6169 void (*copyfunc)(bNodeTree *dest_ntree,
6170 bNode *dest_node,
6171 const bNode *src_node))
6172{
6173 ntype.storagename = storagename.value_or("");
6174 ntype.copyfunc = copyfunc;
6175 ntype.freefunc = freefunc;
6176}
6177
6179{
6181}
6182
6184{
6185 get_node_type_alias_map().clear();
6186
6187 const Vector<bNodeType *> node_types = get_node_type_map().extract_vector();
6188 for (bNodeType *nt : node_types) {
6189 if (nt->rna_ext.free) {
6190 nt->rna_ext.free(nt->rna_ext.data);
6191 }
6192 node_free_type(nt);
6193 }
6194
6196 for (bNodeSocketType *st : socket_types) {
6197 if (st->ext_socket.free) {
6198 st->ext_socket.free(st->ext_socket.data);
6199 }
6200 if (st->ext_interface.free) {
6201 st->ext_interface.free(st->ext_interface.data);
6202 }
6204 }
6205
6206 const Vector<bNodeTreeType *> tree_types = get_node_tree_type_map().extract_vector();
6207 for (bNodeTreeType *nt : tree_types) {
6208 if (nt->rna_ext.free) {
6209 nt->rna_ext.free(nt->rna_ext.data);
6210 }
6211 ntree_free_type(nt);
6212 }
6213}
6214
6215/* -------------------------------------------------------------------- */
6216/* NodeTree Iterator Helpers (FOREACH_NODETREE_BEGIN) */
6217
6219{
6220 ntreeiter->ngroup = bmain->nodetrees.first();
6221 ntreeiter->scene = bmain->scenes.first();
6222 ntreeiter->mat = bmain->materials.first();
6223 ntreeiter->tex = bmain->textures.first();
6224 ntreeiter->light = bmain->lights.first();
6225 ntreeiter->world = bmain->worlds.first();
6226 ntreeiter->linestyle = bmain->linestyles.first();
6227}
6228bool node_tree_iterator_step(NodeTreeIterStore *ntreeiter, bNodeTree **r_nodetree, ID **r_id)
6229{
6230 if (ntreeiter->ngroup) {
6231 bNodeTree &node_tree = *ntreeiter->ngroup;
6232 *r_nodetree = &node_tree;
6233 *r_id = &node_tree.id;
6234 ntreeiter->ngroup = reinterpret_cast<bNodeTree *>(node_tree.id.next);
6235 return true;
6236 }
6237 if (ntreeiter->scene) {
6238 /* Embedded compositing trees are deprecated, but still relevant for versioning/backward
6239 * compatibility. */
6240 *r_nodetree = reinterpret_cast<bNodeTree *>(ntreeiter->scene->nodetree);
6241 *r_id = &ntreeiter->scene->id;
6242 ntreeiter->scene = reinterpret_cast<Scene *>(ntreeiter->scene->id.next);
6243 return true;
6244 }
6245 if (ntreeiter->mat) {
6246 *r_nodetree = reinterpret_cast<bNodeTree *>(ntreeiter->mat->nodetree);
6247 *r_id = &ntreeiter->mat->id;
6248 ntreeiter->mat = reinterpret_cast<Material *>(ntreeiter->mat->id.next);
6249 return true;
6250 }
6251 if (ntreeiter->tex) {
6252 *r_nodetree = reinterpret_cast<bNodeTree *>(ntreeiter->tex->nodetree);
6253 *r_id = &ntreeiter->tex->id;
6254 ntreeiter->tex = reinterpret_cast<Tex *>(ntreeiter->tex->id.next);
6255 return true;
6256 }
6257 if (ntreeiter->light) {
6258 *r_nodetree = reinterpret_cast<bNodeTree *>(ntreeiter->light->nodetree);
6259 *r_id = &ntreeiter->light->id;
6260 ntreeiter->light = reinterpret_cast<Light *>(ntreeiter->light->id.next);
6261 return true;
6262 }
6263 if (ntreeiter->world) {
6264 *r_nodetree = reinterpret_cast<bNodeTree *>(ntreeiter->world->nodetree);
6265 *r_id = &ntreeiter->world->id;
6266 ntreeiter->world = reinterpret_cast<World *>(ntreeiter->world->id.next);
6267 return true;
6268 }
6269 if (ntreeiter->linestyle) {
6270 *r_nodetree = reinterpret_cast<bNodeTree *>(ntreeiter->linestyle->nodetree);
6271 *r_id = &ntreeiter->linestyle->id;
6272 ntreeiter->linestyle = reinterpret_cast<FreestyleLineStyle *>(ntreeiter->linestyle->id.next);
6273 return true;
6274 }
6275
6276 return false;
6277}
6278
6279void node_tree_remove_layer_n(bNodeTree *ntree, Scene *scene, const int layer_index)
6280{
6281 BLI_assert(layer_index != -1);
6282 BLI_assert(scene != nullptr);
6283 for (bNode *node : ntree->all_nodes()) {
6284 if (node->type_legacy == CMP_NODE_R_LAYERS && node->id == &scene->id) {
6285 if (node->custom1 == layer_index) {
6286 node->custom1 = 0;
6287 }
6288 else if (node->custom1 > layer_index) {
6289 node->custom1--;
6290 }
6291 }
6292 }
6293}
6294
6296 const eNodeSocketDatatype socket_type)
6297{
6298 if (bke::bNodeTreeType *ttype = bke::node_tree_type_find_builtin(ntree_type)) {
6300 if (stype && ttype->valid_socket_type) {
6301 return ttype->valid_socket_type(ttype, stype);
6302 }
6303 }
6304 return false;
6305}
6306
6307} // namespace bke
6308} // namespace blender
#define G_MAIN
#define IDP_BlendDataRead(reader, prop)
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
#define BKE_LIB_FOREACHID_PROCESS_ID(data_, id_, cb_flag_)
#define NODE_CLASS_OUTPUT
Definition BKE_node.hh:479
#define NODE_UNDEFINED
Definition BKE_node.hh:863
#define NODE_CLASS_INTERFACE
Definition BKE_node.hh:490
#define NODE_CUSTOM_GROUP
Definition BKE_node.hh:870
#define NODE_CLASS_MATTE
Definition BKE_node.hh:485
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define NODE_LEGACY_TYPE_GENERATION_START
Definition BKE_node.hh:872
#define NODE_CUSTOM
Definition BKE_node.hh:864
#define NODE_CLASS_PATTERN
Definition BKE_node.hh:487
#define NODE_CLASS_GEOMETRY
Definition BKE_node.hh:492
#define NODE_CLASS_DISTORT
Definition BKE_node.hh:486
#define FOREACH_NODETREE_END
Definition BKE_node.hh:936
#define NODE_CLASS_OP_VECTOR
Definition BKE_node.hh:481
#define NODE_CLASS_LAYOUT
Definition BKE_node.hh:494
#define FOREACH_NODETREE_BEGIN(bmain, _nodetree, _id)
Definition BKE_node.hh:926
#define NODE_CLASS_OP_COLOR
Definition BKE_node.hh:480
#define NODE_CLASS_INPUT
Definition BKE_node.hh:478
#define NODE_CLASS_OP_FILTER
Definition BKE_node.hh:482
#define NODE_CLASS_GROUP
Definition BKE_node.hh:483
#define NODE_CLASS_ATTRIBUTE
Definition BKE_node.hh:493
#define NODE_CLASS_TEXTURE
Definition BKE_node.hh:488
#define NODE_CLASS_SHADER
Definition BKE_node.hh:491
#define NODE_CLASS_SCRIPT
Definition BKE_node.hh:489
#define GEO_NODE_MERGE_BY_DISTANCE
#define GEO_NODE_TRIANGULATE
#define CMP_NODE_PREMULKEY
#define CMP_NODE_DENOISE
#define CMP_NODE_MASK
#define CMP_NODE_SCALE
#define GEO_NODE_SUBDIVISION_SURFACE
#define GEO_NODE_INPUT_OBJECT
#define SH_NODE_CURVE_FLOAT
#define CMP_NODE_TIME
#define CMP_NODE_COLOR_SPILL
#define CMP_NODE_VIEWER
#define CMP_NODE_CORNERPIN
#define GEO_NODE_MESH_TO_VOLUME
#define CMP_NODE_MASK_ELLIPSE
#define CMP_NODE_DISPLACE
#define SH_NODE_TEX_IMAGE
#define CMP_NODE_CRYPTOMATTE
#define CMP_NODE_TRANSLATE
#define GEO_NODE_VIEWER
#define GEO_NODE_UV_PACK_ISLANDS
#define CMP_NODE_MOVIEDISTORTION
#define CMP_NODE_TONEMAP
#define CMP_NODE_COLORBALANCE
#define GEO_NODE_REMOVE_ATTRIBUTE
#define GEO_NODE_UV_UNWRAP
#define FN_NODE_INPUT_COLOR
#define CMP_NODE_ROTATE
#define CMP_NODE_KUWAHARA
#define CMP_NODE_FILTER
#define FN_NODE_INPUT_VECTOR
#define SH_NODE_TEX_ENVIRONMENT
#define SH_NODE_NORMAL_MAP
#define SH_NODE_VALUE
#define SH_NODE_CURVE_VEC
#define CMP_NODE_HUECORRECT
#define SH_NODE_TEX_IES
#define GEO_NODE_TRANSFORM_GEOMETRY
#define FN_NODE_INPUT_STRING
#define CMP_NODE_GLARE
#define GEO_NODE_RAYCAST
#define CMP_NODE_TRANSFORM
#define CMP_NODE_DILATEERODE
#define GEO_NODE_INPUT_COLLECTION
#define CMP_NODE_LENSDIST
#define GEO_NODE_SAMPLE_GRID
#define FN_NODE_INPUT_INT
#define GEO_NODE_FILLET_CURVE
#define CMP_NODE_MAP_UV
#define FN_NODE_INPUT_BOOL
#define CMP_NODE_CRYPTOMATTE_LEGACY
#define CMP_NODE_TRACKPOS
#define TEX_NODE_IMAGE
#define CMP_NODE_OUTPUT_FILE
#define CMP_NODE_SETALPHA
#define SH_NODE_BSDF_HAIR_PRINCIPLED
#define CMP_NODE_CURVE_RGB
#define CMP_NODE_DOUBLEEDGEMASK
#define GEO_NODE_RESAMPLE_CURVE
#define CMP_NODE_STABILIZE2D
#define SH_NODE_VECTOR_DISPLACEMENT
#define SH_NODE_VALTORGB
#define GEO_NODE_SCALE_ELEMENTS
#define SH_NODE_CURVE_RGB
#define GEO_NODE_IMAGE
#define GEO_NODE_CAPTURE_ATTRIBUTE
#define CMP_NODE_MASK_BOX
#define GEO_NODE_FILL_CURVE
#define TEX_NODE_CURVE_TIME
#define CMP_NODE_KEYING
#define GEO_NODE_STRING_TO_CURVES
#define GEO_NODE_POINTS_TO_VOLUME
#define CMP_NODE_R_LAYERS
#define GEO_NODE_INPUT_MATERIAL
#define GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME
#define CMP_NODE_DIST_MATTE
#define CMP_NODE_IMAGE
#define CMP_NODE_VIEW_LEVELS
#define CMP_NODE_CURVE_VEC_DEPRECATED
#define CMP_NODE_BLUR
#define FN_NODE_INPUT_ROTATION
#define TEX_NODE_VALTORGB
#define SH_NODE_SCRIPT
#define GEO_NODE_VOLUME_TO_MESH
#define GEO_NODE_SET_CURVE_NORMAL
#define TEX_NODE_CURVE_RGB
#define CMP_NODE_CHANNEL_MATTE
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
#define STR_ELEM(...)
#define SNPRINTF_UTF8(dst, format,...)
#define STRNCPY_UTF8(dst, src)
Platform independent time functions.
#define BLO_read_raw_address(reader, ptr_p)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_NODETREE
#define IFACE_(msgid)
#define DATA_(msgid)
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define CLOG_WARN(clg_ref,...)
Definition CLG_log.h:189
#define FILTER_ID_ALL
Definition DNA_ID.h:1241
#define MAX_IDPROP_NAME
Definition DNA_ID.h:174
#define FILTER_ID_NT
Definition DNA_ID.h:1215
Object groups, one object can be in many groups at once.
#define MAX_NAME
Definition DNA_defs.h:63
#define RE_PASSNAME_COMBINED
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define BLI_assert_unreachable()
#define SET_FLAG_FROM_TEST(value, test, flag)
#define ELEM(...)
#define BLI_assert_msg(a, msg)
#define STREQ(a, b)
#define output
bool is_any() const
static const CPPType & get()
bool is() const
void destruct(void *ptr) const
constexpr int64_t last(const int64_t n=0) const
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
const Value * lookup_ptr_as(const ForwardKey &key) const
Definition BLI_map.hh:516
void add_new(const Key &key, const Value &value)
Definition BLI_map.hh:265
ItemIterator items() const &
Definition BLI_map.hh:902
static RandomNumberGenerator from_random_seed()
Definition rand.cc:288
void add_destruct_call(Func func)
bool contains(const Key &key) const
Definition BLI_set.hh:310
bool add(const Key &key)
Definition BLI_set.hh:248
bool is_empty() const
Definition BLI_stack.hh:310
void push(const T &value)
Definition BLI_stack.hh:215
constexpr const char * c_str() const
constexpr StringRefNull()
bool is_empty() const
const char * c_str() const
StringRefNull ref() const
UString()=default
const Key & lookup_key_as(const ForwardKey &key) const
bool contains_as(const ForwardKey &key) const
void reserve(const int64_t n)
int64_t index_of(const Key &key) const
IndexRange index_range() const
bool contains(const Key &key) const
Span< Key > as_span() const
void add_new(const Key &key)
void append_non_duplicates(const T &value)
Vector< bNodeInternalLink > internal_links
const nodes::SocketDeclaration * declaration
std::unique_ptr< node_tree_reference_lifetimes::ReferenceLifetimesInfo > reference_lifetimes_info
std::shared_ptr< nodes::GeneratedTreeSrnaData > compositor_effect_nodes_srna_data
std::shared_ptr< nodes::GeneratedTreeSrnaData > scene_compositor_effect_srna_data
std::unique_ptr< nodes::EvalDependencies > eval_dependencies
std::unique_ptr< nodes::StructureTypeInterface > structure_type_interface
std::shared_ptr< nodes::GeneratedTreeSrnaData > geometry_nodes_srna_data
std::shared_ptr< nodes::GeneratedTreeSrnaData > compositor_nodes_srna_data
void copy_utf8_truncated(char *dst, int64_t dst_size) const
Definition string_ref.cc:28
std::unique_ptr< CustomSocketLabelFn > label_fn
std::optional< std::string > translation_context
#define offsetof(t, d)
#define str(s)
#define FLT_MAX
#define INT_MAX
#define main()
#define storage(slot, qualifiers)
float length(VecOp< float, D >) RET
#define T
static void free_legacy_socket_storage(bNode &node)
Definition node.cc:1073
static void initialize_legacy_socket_storage(bNode &node)
Definition node.cc:1055
static void write_default_value_none_subtype(BlendWriter *writer, const void *default_value)
Definition node.cc:1099
static void update_node_location_legacy(bNodeTree &ntree)
Definition node.cc:591
static void write_legacy_properties(bNodeTree &ntree, Map< ID **, ID * > &r_ids_to_restore)
Definition node.cc:603
static void pixel_subtype_forward_compat(BlendWriter *writer, const bNodeSocket &sock)
Definition node.cc:1107
static const Map< StringRef, StringRef > & subtype_pixel_to_none()
Definition node.cc:1085
std::unique_ptr< IDProperty, IDPropertyDeleter > create_bool(StringRef prop_name, bool value, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_BOOLEAN, set its name and value.
std::unique_ptr< IDProperty, IDPropertyDeleter > create(StringRef prop_name, int32_t value, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_INT, set its name and value.
std::unique_ptr< IDProperty, IDPropertyDeleter > create_group(StringRef prop_name, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_GROUP.
T & get_socket_data_as(bNodeTreeInterfaceSocket &item)
bool topology_cache_is_available(const bNodeTree &tree)
constexpr int MIN_BLENDFILE_VERSION_FOR_MODERN_NODE_SOCKET_DEFAULT_VALUE_READING
Definition node.cc:1522
static void direct_link_node_socket_legacy_data_version_do(void **dest_data, void **raw_data, FunctionRef< void(T &dest, T_404 &source)> copy_fn)
Definition node.cc:1612
void node_unregister_socket_type(bNodeSocketType &stype)
Definition node.cc:3007
bNode * node_find_node_by_name(bNodeTree &ntree, StringRefNull name)
Definition node.cc:4047
bNodeSocket * node_find_enabled_input_socket(bNode &node, StringRef name)
Definition node.cc:3068
void node_position_propagate(bNode &node)
Definition node.cc:4942
void node_chain_iterator_backwards(const bNodeTree *ntree, bNode *node_start, bool(*callback)(bNode *, bNode *, void *), void *userdata, int recursion_lvl)
Definition node.cc:4206
NodeColorTag node_color_tag(const bNode &node)
Definition node.cc:5788
void * socket_value_copy(eNodeSocketDatatype type, const void *src, bool do_id_user)
Definition node.cc:3285
static void node_free_type(void *nodetype_v)
Definition node.cc:2901
void node_socket_declarations_update(bNode *node)
Definition node.cc:5546
void node_tree_free_local_node(bNodeTree &ntree, bNode &node)
Definition node.cc:5141
void node_tree_set_output(bNodeTree &ntree)
Definition node.cc:5238
static ID ** node_owner_pointer_get(ID *id, const bool debug_relationship_assert)
Definition node.cc:572
const bNodeZoneType * zone_type_by_node_type(const int node_type)
void node_modify_socket_type_static(bNodeTree *ntree, bNode *node, bNodeSocket *sock, int type, int subtype)
Definition node.cc:3448
bNodeSocketType NodeSocketTypeUndefined
Definition node.cc:135
std::string node_label(const bNodeTree &ntree, const bNode &node)
Definition node.cc:5732
std::optional< eNodeSocketDatatype > geo_nodes_base_cpp_type_to_socket_type(const CPPType &type)
Definition node.cc:6008
static bNodeSocket * make_socket(bNodeTree *ntree, bNode *, const eNodeSocketInOut in_out, ListBaseT< bNodeSocket > *lb, const StringRefNull idname, const StringRefNull identifier, const StringRefNull name)
Definition node.cc:3078
void node_tree_remove_layer_n(bNodeTree *ntree, Scene *scene, int layer_index)
Definition node.cc:6279
bool node_is_parent_and_child(const bNode &parent, const bNode &child)
Definition node.cc:4115
void node_attach_node(bNodeTree &ntree, bNode &node, bNode &parent)
Definition node.cc:4883
void node_tree_node_flag_set(bNodeTree &ntree, eNode_Flag flag, bool enable)
Definition node.cc:5343
void node_tree_blend_read_data(BlendDataReader *reader, ID *owner_id, bNodeTree *ntree)
Definition node.cc:2087
static void node_foreach_working_space_color(ID *id, const IDTypeForeachColorFunctionCallback &fn)
Definition node.cc:500
static bool node_poll_default(const bNodeType *, const bNodeTree *, const char **)
Definition node.cc:5839
const bNodeTreeInterfaceSocket * node_find_interface_input_by_identifier(const bNodeTree &ntree, StringRef identifier)
Definition node.cc:4079
bool node_tree_is_registered(const bNodeTree &ntree)
Definition node.cc:2873
static void node_init(const bContext *C, bNodeTree *ntree, bNode *node)
Definition node.cc:2590
static void node_type_base_defaults(bNodeType &ntype)
Definition node.cc:5831
static void direct_link_node_socket_default_value(BlendDataReader *reader, bNodeSocket *sock)
Definition node.cc:1629
bNodeTreeType * node_tree_type_find(StringRef idname)
Definition node.cc:2797
static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo)
Definition node.cc:2645
void node_unlink_node(bNodeTree &ntree, bNode &node)
Definition node.cc:5026
void node_tree_free_tree(bNodeTree &ntree)
Definition node.cc:5224
Span< bNodeSocketType * > node_socket_types_get()
Definition node.cc:2961
void node_tag_update_id(bNode &node)
Definition node.cc:5593
static void socket_value_init_impl(T &, const int)
Definition node.cc:3168
bNodeTree * node_tree_add_tree_embedded(Main *bmain, ID *owner_id, StringRefNull name, StringRefNull idname)
Definition node.cc:5005
std::optional< VolumeGridType > socket_type_to_grid_type(eNodeSocketDatatype type)
Definition node.cc:6080
bNodeTree * node_tree_copy_tree(Main *bmain, const bNodeTree &ntree)
Definition node.cc:5021
void node_remove_node(Main *bmain, bNodeTree &ntree, bNode &node, bool do_id_user, bool remove_animation=true)
Definition node.cc:5155
bool node_socket_is_registered(const bNodeSocket &sock)
Definition node.cc:3013
bool node_tree_iterator_step(NodeTreeIterStore *ntreeiter, bNodeTree **r_nodetree, ID **r_id)
Definition node.cc:6228
static Set< int > get_known_node_types_set()
Definition node.cc:5635
bNode * node_get_active(bNodeTree &ntree)
Definition node.cc:5445
static void defer_free_tree_type(bNodeTreeType *tree_type)
Definition node.cc:2816
void node_tree_blend_write(BlendWriter *writer, bNodeTree *ntree)
Definition node.cc:1361
static void node_foreach_path(ID *id, BPathForeachPathData *bpath_data)
Definition node.cc:452
bool node_link_is_selected(const bNodeLink &link)
Definition node.cc:4770
static const CPPType * slow_socket_type_to_geo_nodes_base_cpp_type(const eNodeSocketDatatype type)
Definition node.cc:5963
void node_remove_socket(bNodeTree &ntree, bNode &node, bNodeSocket &sock)
Definition node.cc:4015
void node_update_asset_metadata(bNodeTree &node_tree)
Definition node.cc:2462
static bool is_node_socket_supported(const bNodeSocket *sock)
Definition node.cc:1470
const DataTypeConversions & get_implicit_type_conversions()
static void remove_unsupported_sockets(ListBaseT< bNodeSocket > *sockets, ListBaseT< bNodeLink > *links)
Definition node.cc:1961
static void defer_free_node_type(bNodeType *ntype)
Definition node.cc:2822
static void ntree_copy_data(Main *, std::optional< Library * >, ID *id_dst, const ID *id_src, const int flag)
Definition node.cc:154
static auto & get_socket_type_map()
Definition node.cc:2791
static void node_blend_write_storage(BlendWriter *writer, bNodeTree *ntree, bNode *node)
Definition node.cc:1263
void node_unique_id(bNodeTree &ntree, bNode &node)
Definition node.cc:4244
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
void * socket_value_new(eNodeSocketDatatype type, int subtype=0)
Definition node.cc:3274
std::optional< StringRefNull > node_socket_short_label(const bNodeSocket &sock)
Definition node.cc:5747
static void ntree_free_data(ID *id)
Definition node.cc:268
static void adjust_multi_input_indices_after_removed_link(bNodeTree *ntree, const bNodeSocket *sock, const int deleted_index)
Definition node.cc:4798
static void ntree_blend_read_after_liblink(BlendLibReader *reader, ID *id)
Definition node.cc:2213
void node_set_socket_availability(bNodeTree &ntree, bNodeSocket &sock, bool is_available)
Definition node.cc:5499
const char * node_socket_translation_context(const bNodeSocket &sock)
Definition node.cc:5770
void node_remove_link(bNodeTree *ntree, bNodeLink &link)
Definition node.cc:4676
void node_chain_iterator(const bNodeTree *ntree, const bNode *node_start, bool(*callback)(bNode *, bNode *, void *, const bool), void *userdata, bool reversed)
Definition node.cc:4125
static bool ntree_contains_tree_exec(const bNodeTree &tree_to_search_in, const bNodeTree &tree_to_search_for, Set< const bNodeTree * > &already_passed)
Definition node.cc:5398
Span< bNodeType * > node_types_get()
Definition node.cc:2951
static bool can_read_node_type(const bNode &node)
Definition node.cc:5644
IDProperty * node_create_asset_meta_data_properties(const bNodeTree &node_tree)
Definition node.cc:2415
std::optional< StringRefNull > node_static_socket_interface_type_new(int type, int subtype, std::optional< int > dimensions=std::nullopt)
Definition node.cc:3709
static void ntree_init_data(ID *id)
Definition node.cc:145
void node_tree_set_type(bNodeTree &ntree)
Definition node.cc:2748
bool node_declaration_ensure_on_outdated_node(bNodeTree &ntree, bNode &node)
Definition node.cc:5558
static void direct_link_node_socket_storage(BlendDataReader *reader, const bNode *node, bNodeSocket *sock)
Definition node.cc:1907
void socket_value_init(eNodeSocketDatatype type, void *data, int subtype=0)
Definition node.cc:3265
bNode * node_add_node(const bContext *C, bNodeTree &ntree, UString idname, std::optional< int > unique_identifier=std::nullopt)
Definition node.cc:4260
void node_tree_type_add(bNodeTreeType &nt)
Definition node.cc:2844
void node_tree_update_all_new(Main &main)
Definition node.cc:5677
void node_tree_iterator_init(NodeTreeIterStore *ntreeiter, Main *bmain)
Definition node.cc:6218
static bNodeInstanceKey node_hash_int_str(bNodeInstanceKey hash, const char *str)
Definition node.cc:5607
bNodeType * node_type_find(UString idname)
Definition node.cc:2883
static int16_t get_next_auto_legacy_type()
Definition node.cc:5853
std::optional< eNodeSocketDatatype > grid_type_to_socket_type(VolumeGridType type)
Definition node.cc:6096
void node_node_foreach_id(bNode *node, LibraryForeachIDData *data)
Definition node.cc:404
bNodeTreeType NodeTreeTypeUndefined
Definition node.cc:133
static void node_set_typeinfo(const bContext *C, bNodeTree *ntree, bNode *node, bNodeType *typeinfo)
Definition node.cc:2659
static void node_tree_asset_on_clear_asset(void *asset_ptr, AssetMetaData *asset_data)
Definition node.cc:2507
bNodeTree ** node_tree_ptr_from_id(ID *id)
Definition node.cc:5312
bNodeTree * node_tree_localize(bNodeTree *ntree, std::optional< ID * > new_owner_id)
Definition node.cc:5355
void node_parents_iterator(bNode *node, bool(*callback)(bNode *, void *), void *userdata)
Definition node.cc:4228
void node_unlink_attached(bNodeTree *ntree, const bNode *parent)
Definition node.cc:5053
void node_type_base(bNodeType &ntype, UString idname, std::optional< int16_t > legacy_type=std::nullopt)
Definition node.cc:5866
int node_count_socket_links(const bNodeTree &ntree, const bNodeSocket &sock)
Definition node.cc:5434
void node_internal_relink(bNodeTree &ntree, bNode &node)
Definition node.cc:4812
bNode * node_find_node_try(bNodeTree &ntree, bNodeSocket &socket)
Definition node.cc:4065
static void direct_link_node_socket(BlendDataReader *reader, const bNode *node, bNodeSocket *sock)
Definition node.cc:1944
const bNodeInstanceKey NODE_INSTANCE_KEY_BASE
Definition node.cc:5600
std::optional< eNodeSocketDatatype > custom_data_type_to_socket_type(eCustomDataType type)
Definition node.cc:5935
void node_system_exit()
Definition node.cc:6183
void node_free_node(bNodeTree *tree, bNode &node)
Definition node.cc:5073
bNodeType NodeTypeUndefined
Definition node.cc:134
static void node_foreach_id(ID *id, LibraryForeachIDData *data)
Definition node.cc:428
static void node_socket_free_default_value(bNodeSocket *sock, const bool do_id_user)
Definition node.cc:3370
void node_tree_type_free_link(const bNodeTreeType &nt)
Definition node.cc:2867
void node_type_socket_templates(bNodeType *ntype, bNodeSocketTemplate *inputs, bNodeSocketTemplate *outputs)
Definition node.cc:6134
bNodeInstanceKey node_instance_key(bNodeInstanceKey parent_key, const bNodeTree *ntree, const bNode *node)
Definition node.cc:5621
static void ntree_blend_read_data(BlendDataReader *reader, ID *id)
Definition node.cc:2207
static bool get_socket_value(bNodeSocket &socket, void *buffer)
Definition node.cc:4494
static void node_socket_copy(bNodeSocket *sock_dst, const bNodeSocket *sock_src, const int flag)
Definition node.cc:4307
static void node_update_idname_from_experimental(bNode &node)
Definition node.cc:2071
void node_register_socket_type(bNodeSocketType &stype)
Definition node.cc:2998
static ID * socket_value_get_id_ptr(const eNodeSocketDatatype type, void *data)
Definition node.cc:3130
static bool check_link_selected_backward(const bNodeLink &link, Set< const bNode * > &visited_nodes)
Definition node.cc:4716
static auto & get_node_tree_type_map()
Definition node.cc:2773
static void reset_socket_declarations(ListBaseT< bNodeSocket > *sockets)
Definition node.cc:5539
static bool node_poll_instance_default(const bNode *node, const bNodeTree *ntree, const char **r_disabled_hint)
Definition node.cc:5846
void node_set_undefined_type(bNode &node)
Definition node.cc:5667
bNodeSocket * node_find_enabled_output_socket(bNode &node, StringRef name)
Definition node.cc:3073
const CPPType * socket_type_to_geo_nodes_base_cpp_type(eNodeSocketDatatype type)
Definition node.cc:5969
void node_position_relative(bNode &from_node, const bNode &to_node, const bNodeSocket *from_sock, const bNodeSocket &to_sock)
Definition node.cc:4900
bool node_set_selected(bNode &node, bool select)
Definition node.cc:5455
bNodeSocket * node_add_socket(bNodeTree &ntree, bNode &node, eNodeSocketInOut in_out, StringRefNull idname, StringRefNull identifier, StringRefNull name)
Definition node.cc:3461
bNode & node_find_node(bNodeTree &ntree, bNodeSocket &socket)
Definition node.cc:4053
static void node_tree_asset_pre_save(void *asset_ptr, AssetMetaData *)
Definition node.cc:2489
static auto & get_node_type_alias_map()
Definition node.cc:2785
bool node_tree_contains_tree(const bNodeTree &tree_to_search_in, const bNodeTree &tree_to_search_for)
Definition node.cc:5423
void socket_value_free(eNodeSocketDatatype type, void *data, bool do_id_user)
Definition node.cc:3347
void node_detach_node(bNodeTree &ntree, bNode &node)
Definition node.cc:4891
static void node_free_socket_type(void *socktype_v)
Definition node.cc:2984
void node_rebuild_id_vector(bNodeTree &node_tree)
Definition node.cc:5062
bNodeSocketType * node_socket_type_find(StringRef idname)
Definition node.cc:2966
bNode * node_add_static_node(const bContext *C, bNodeTree &ntree, int type)
Definition node.cc:4283
bNodeTree * node_tree_copy_tree_ex(const bNodeTree &ntree, Main *bmain, bool do_id_user)
Definition node.cc:5013
static bool store_socket_value(bNode &node, const bNodeSocket &socket, const void *value)
Definition node.cc:4421
bool node_supports_active_flag(const bNode &node, int sub_activity)
Does the given node supports the sub active flag.
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4638
bNodeSocket * node_find_enabled_socket(bNode &node, eNodeSocketInOut in_out, StringRef name)
Definition node.cc:3055
UString node_type_find_alias(UString alias)
Definition node.cc:2892
static std::unique_ptr< IDProperty, idprop::IDPropertyDeleter > create_socket_meta_data_properties(const bNodeTreeInterfaceSocket &socket, const bool create_default_value_properties)
Definition node.cc:2239
static void node_blend_read_data_storage(BlendDataReader *reader, bNodeTree *ntree, bNode *node)
Definition node.cc:1988
bNodeTree * node_tree_add_tree(Main *bmain, StringRef name, StringRef idname)
Definition node.cc:4992
bool socket_data_to_static_type(const eNodeSocketDatatype type, Fn &&fn)
Definition BKE_node.hh:1058
static void update_socket_declarations(ListBaseT< bNodeSocket > *sockets, const Span< SocketDeclaration * > declarations)
Definition node.cc:5529
bNodeSocketType * node_socket_type_find_static(int type, int subtype=0)
Definition node.cc:2975
static void free_localized_node_groups(bNodeTree *ntree)
Definition node.cc:5205
void node_link_set_mute(bNodeTree &ntree, bNodeLink &link, const bool muted)
Definition node.cc:4693
StringRefNull node_socket_type_label(const bNodeSocketType &stype)
Definition node.cc:3018
static bNodeTree * node_tree_add_tree_do(Main *bmain, std::optional< Library * > owner_library, ID *owner_id, const bool is_embedded, const StringRef name, const StringRef idname)
Definition node.cc:4953
Span< bNodeTreeType * > node_tree_types_get()
Definition node.cc:2878
bNodeSocket * node_add_static_socket(bNodeTree &ntree, bNode &node, eNodeSocketInOut in_out, int type, int subtype, StringRefNull identifier, StringRefNull name)
Definition node.cc:3980
void socket_value_copy_content(eNodeSocketDatatype type, void *dst, const void *src, bool do_id_user)
Definition node.cc:3312
static void library_foreach_node_socket(bNodeSocket *sock, LibraryForeachIDData *data)
Definition node.cc:324
bNodeSocket * node_find_socket(bNode &node, eNodeSocketInOut in_out, UString identifier)
Definition node.cc:3036
void node_remove_socket_ex(bNodeTree &ntree, bNode &node, bNodeSocket &sock, bool do_id_user)
Definition node.cc:4020
static void iter_backwards_ex(const bNodeTree *ntree, bNode *node_start, bool(*callback)(bNode *, bNode *, void *), void *userdata, const char recursion_mask)
Definition node.cc:4157
void node_register_alias(bNodeType &nt, UString alias)
Definition node.cc:2956
static void ntree_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition node.cc:1452
void node_unregister_type(bNodeType &ntype)
Definition node.cc:2945
void node_modify_socket_type(bNodeTree &ntree, bNode &node, bNodeSocket &sock, StringRefNull idname)
Definition node.cc:3380
bNode * node_copy_with_mapping(bNodeTree *dst_tree, const bNode &node_src, int flag, std::optional< StringRefNull > dst_unique_name, std::optional< int > dst_unique_identifier, Map< const bNodeSocket *, bNodeSocket * > &new_socket_map, bool allow_duplicate_names=false)
Definition node.cc:4327
std::optional< StringRefNull > node_static_socket_label(int type, int subtype)
Definition node.cc:3923
const bNodeTreeInterfaceSocket * node_find_interface_output_by_identifier(const bNodeTree &ntree, StringRef identifier)
Definition node.cc:4091
std::optional< StringRefNull > node_static_socket_type(int type, int subtype, std::optional< int > dimensions=std::nullopt)
Definition node.cc:3492
void node_system_init()
Definition node.cc:6178
static void node_add_sockets_from_type(bNodeTree *ntree, bNode *node, bNodeType *ntype)
Definition node.cc:2562
void node_remove_socket_links(bNodeTree &ntree, bNodeSocket &sock)
Definition node.cc:4702
const bNodeInstanceKey NODE_INSTANCE_KEY_NONE
Definition node.cc:5601
bool node_declaration_ensure(bNodeTree &ntree, bNode &node)
Definition node.cc:5578
void node_set_active(bNodeTree &ntree, bNode &node)
Definition node.cc:5484
float2 node_dimensions_get(const bNode &node)
Definition node.cc:5587
bNodeTree * node_tree_add_in_lib(Main *bmain, Library *owner_library, StringRefNull name, StringRefNull idname)
Definition node.cc:4997
static void update_typeinfo(Main *bmain, bNodeTreeType *treetype, bNodeType *nodetype, bNodeSocketType *socktype, const bool unregister)
Definition node.cc:2711
static void ntree_free_type(void *treetype_v)
Definition node.cc:2853
void socket_value_id_user_decrement(eNodeSocketDatatype type, void *data)
Definition node.cc:3160
static int node_count_links(const bNodeTree *ntree, const bNodeSocket *socket)
Definition node.cc:4627
static void unique_socket_template_identifier(bNodeSocketTemplate *list, bNodeSocketTemplate *ntemp, const char defname[], const char delim)
Definition node.cc:6112
static void write_node_socket_default_value(BlendWriter *writer, const bNodeSocket *sock)
Definition node.cc:1161
static void node_tree_asset_on_mark_asset(void *asset_ptr, AssetMetaData *asset_data)
Definition node.cc:2495
void node_socket_move_default_value(Main &bmain, bNodeTree &tree, bNodeSocket &src, bNodeSocket &dst)
Definition node.cc:4534
bNodeTree * node_tree_from_id(ID *id)
Definition node.cc:5337
void node_tree_update_all_users(Main *main, ID *id)
Definition node.cc:5707
int node_socket_link_limit(const bNodeSocket &sock)
Definition node.cc:5513
void node_clear_active(bNodeTree &ntree)
Definition node.cc:5477
bNodeTreeType * node_tree_type_find_builtin(const int tree_type)
Definition node.cc:2806
static bool check_link_selected_forward(const bNodeLink &link, Set< const bNode * > &visited_nodes)
Definition node.cc:4743
StringRefNull node_socket_sub_type_label(int subtype)
Definition node.cc:3027
void socket_value_id_user_increment(eNodeSocketDatatype type, void *data)
Definition node.cc:3152
bNode * node_find_root_parent(bNode &node)
Definition node.cc:4103
static void node_socket_free(bNodeSocket *sock, const bool do_id_user)
Definition node.cc:4000
StringRefNull node_socket_label(const bNodeSocket &sock)
Definition node.cc:5758
static void node_socket_set_typeinfo(bNodeTree *ntree, bNodeSocket *sock, bNodeSocketType *typeinfo)
Definition node.cc:2689
void node_tree_free_embedded_tree(bNodeTree *ntree)
Definition node.cc:5231
void node_type_storage(bNodeType &ntype, std::optional< StringRefNull > storagename, void(*freefunc)(bNode *node), void(*copyfunc)(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node))
Definition node.cc:6166
static void write_node_socket(BlendWriter *writer, const bNodeSocket *sock)
Definition node.cc:1240
std::optional< eCustomDataType > socket_type_to_custom_data_type(eNodeSocketDatatype type)
Definition node.cc:5911
static void defer_free_socket_type(bNodeSocketType *stype)
Definition node.cc:2833
void node_unique_name(bNodeTree &ntree, bNode &node)
Definition node.cc:4238
bool node_is_static_socket_type(const bNodeSocketType &stype)
Definition node.cc:3483
static auto & get_node_type_map()
Definition node.cc:2779
bool node_tree_type_supports_socket_type_static(const int ntree_type, const eNodeSocketDatatype socket_type)
Definition node.cc:6295
bool node_link_is_hidden(const bNodeLink &link)
Definition node.cc:4711
void node_type_base_custom(bNodeType &ntype, StringRefNull idname, StringRefNull name, StringRefNull enum_name, short nclass)
Definition node.cc:5896
QuaternionBase< float > Quaternion
QuaternionBase< T > normalize_and_get_length(const QuaternionBase< T > &q, T &out_length)
EulerXYZBase< float > EulerXYZ
Euler3Base< T > to_euler(const AxisAngleBase< T, AngleT > &axis_angle, EulerOrder order)
void update_node_declaration_and_sockets(bNodeTree &ntree, bNode &node, Main *bmain)
void build_node_declaration(const bke::bNodeType &typeinfo, NodeDeclaration &r_declaration, const bNodeTree *ntree, const bNode *node)
ImplicitSharingPtr< Closure > ClosurePtr
ImplicitSharingPtr< Bundle > BundlePtr
BMesh Iterators.
UserDef U
Definition blender.cc:58
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
void BKE_ntree_update_tag_node_removed(bNodeTree *ntree)
__int64 int64_t
Definition BKE_text.h:90
@ NODE_ACTIVE_TEXTURE
@ NODE_ACTIVE_PAINT_CANVAS
void IDP_FreeProperty_ex(IDProperty *prop, bool do_id_user)
Definition idprop.cc:1398
void BKE_previewimg_id_free(ID *id)
char * STRNCPY(char(&dst)[N], const char *src)
constexpr bool is_same_any_v
void BKE_ntree_update(Main &bmain, std::optional< Span< bNodeTree * > > modified_trees=std::nullopt, const NodeTreeUpdateExtraParams &params={})
void BKE_asset_metadata_idprop_ensure(AssetMetaData *asset_data, IDProperty *prop)
Definition asset.cc:172
void BKE_ntree_update_tag_link_added(bNodeTree *ntree, bNodeLink *link)
void * BKE_libblock_alloc_in_lib(Main *bmain, std::optional< Library * > owner_library, short type, const char *name, int flag) ATTR_WARN_UNUSED_RESULT
Definition lib_id.cc:1439
bool RNA_struct_is_a(const StructRNA *type, const StructRNA *srna)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void BKE_ntree_update_tag_link_changed(bNodeTree *ntree)
void BKE_previewimg_blend_read(BlendDataReader *reader, PreviewImage *prv)
void * BLO_read_struct_by_name_array(BlendDataReader *reader, StringRef struct_name, int64_t items_num, const void *old_address)
Definition readfile.cc:6521
void BKE_ntree_update_tag_socket_new(bNodeTree *ntree, bNodeSocket *socket)
void id_us_plus(ID *id)
Definition lib_id.cc:433
bool IDP_AddToGroup(IDProperty *group, IDProperty *prop) ATTR_NONNULL()
Definition idprop.cc:788
void BKE_previewimg_blend_write(BlendWriter *writer, const PreviewImage *prv)
GeometryNodeStringToCurvesAlignYMode
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
Definition idprop.cc:1696
const EnumPropertyItem rna_enum_property_subtype_items[]
Definition rna_rna.cc:129
void IDP_foreach_property(IDProperty *id_property_root, int type_filter, FunctionRef< void(IDProperty *id_property)> callback)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
void BKE_curvemapping_curves_blend_write(BlendWriter *writer, const CurveMapping *cumap)
const char * RNA_struct_ui_name(const StructRNA *type)
MatBase< float, 4, 4 > float4x4
void BKE_ntree_update_tag_link_removed(bNodeTree *ntree)
void BKE_ntree_update_tag_parent_change(bNodeTree *ntree, bNode *node)
StructRNA * RNA_struct_find(const char *identifier)
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2890
bool BKE_animdata_fix_paths_remove(ID *id, const char *prefix)
@ LIB_ID_CREATE_NO_USER_REFCOUNT
@ LIB_ID_COPY_NO_PREVIEW
@ LIB_ID_COPY_LOCALIZE
@ LIB_ID_COPY_NO_ANIMDATA
@ LIB_ID_CREATE_NO_MAIN
void BKE_colorband_foreach_working_space_color(ColorBand *coba, const IDTypeForeachColorFunctionCallback &fn)
Definition colorband.cc:655
void BKE_libblock_free_data(ID *id, bool do_id_user) ATTR_NONNULL()
VecBase< float, 4 > float4
size_t void BLI_uniquename_cb(FunctionRef< bool(StringRefNull)> unique_check, const char *defname, char delim, char *name, size_t name_maxncpy) ATTR_NONNULL(2
void BLI_uniquename(const ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void BKE_curvemapping_blend_read(BlendDataReader *reader, CurveMapping *cumap)
@ CMP_NODE_GLARE_SIMPLE_STAR
@ CMP_NODE_GLARE_STREAKS
VecBase< float, 2 > float2
GeometryNodeCurveFilletMode
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
CMPNodeChannelMatteColorSpace
@ CMP_NODE_CHANNEL_MATTE_CS_HSV
@ CMP_NODE_CHANNEL_MATTE_CS_YUV
@ CMP_NODE_CHANNEL_MATTE_CS_RGB
@ CMP_NODE_CHANNEL_MATTE_CS_YCC
BMesh const char void * data
void BKE_animdata_free(ID *id, bool do_id_user)
Definition anim_data.cc:174
bool RNA_enum_name(const EnumPropertyItem *item, const int value, const char **r_name)
@ VOLUME_GRID_VECTOR_FLOAT
VectorSet< T, InlineBufferCapacity, DefaultProbingStrategy, CustomIDHash< T, GetIDFn >, CustomIDEqual< T, GetIDFn > > CustomIDVectorSet
void BKE_ntree_update_tag_socket_removed(bNodeTree *ntree)
void register_nodes()
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
void BKE_ntree_update_tag_node_type(bNodeTree *ntree, bNode *node)
void ntreeTexEndExecTree(struct bNodeTreeExec *exec)
void BKE_ntree_update_tag_socket_type(bNodeTree *ntree, bNodeSocket *socket)
@ NODE_SCRIPT_EXTERNAL
void BKE_image_format_blend_read_data(BlendDataReader *reader, ImageFormatData *imf)
void BKE_libblock_init_empty(ID *id) ATTR_NONNULL(1)
Definition lib_id.cc:1550
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
void BKE_ntree_update_tag_all(bNodeTree *ntree)
GeometryNodeMergeByDistanceMode
void BLO_read_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size, const int elems=1)
void BKE_previewimg_id_copy(ID *new_id, const ID *old_id)
GeometryNodeStringToCurvesAlignXMode
void BKE_libblock_free_runtime_data(ID *id)
void RNA_struct_blender_type_set(StructRNA *srna, void *blender_type)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
void BKE_ntree_update_tag_node_property(bNodeTree *ntree, bNode *node)
bool BKE_bpath_foreach_path_fixed_process(BPathForeachPathData *bpath_data, char *path, size_t path_maxncpy)
Definition bpath.cc:130
bNodeSocket * node_add_socket_from_template(bNodeTree *ntree, bNode *node, bke::bNodeSocketTemplate *stemp, eNodeSocketInOut in_out)
IDTypeInfo IDType_ID_NT
Definition node.cc:2527
@ INDEX_ID_NT
Definition DNA_ID.h:1298
void IDP_FreeProperty(IDProperty *prop)
Definition idprop.cc:1403
@ NODE_VIEWER_SHORTCUT_NONE
int BLO_read_fileversion_get(BlendDataReader *reader)
Definition readfile.cc:6546
void BKE_ntree_update_tag_missing_runtime_data(bNodeTree *ntree)
@ ID_TAG_INDIRECT
Definition DNA_ID.h:851
@ ID_TAG_LOCALIZED
Definition DNA_ID.h:990
@ ID_TAG_EXTERN
Definition DNA_ID.h:845
@ ID_TAG_NEW
Definition DNA_ID.h:922
signed int int32_t
Definition BKE_text.h:78
static AssetTypeInfo AssetType_NT
Definition node.cc:2521
static CLG_LogRef LOG
Definition node.cc:125
bool BLO_read_lib_is_undo(BlendLibReader *reader)
Definition readfile.cc:6848
void DEG_relations_tag_update(Main *bmain)
char * BLI_strdup_null(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_MALLOC
@ ID_FLAG_EMBEDDED_DATA
Definition DNA_ID.h:775
void ntreeShaderEndExecTree(struct bNodeTreeExec *exec)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
void BKE_ntree_update_tag_socket_availability(bNodeTree *ntree, bNodeSocket *socket)
MINLINE void copy_v4_v4(float r[4], const float a[4])
ID * BKE_id_copy_ex(Main *bmain, const ID *id, ID **new_id_p, int flag)
Definition lib_id.cc:851
@ IDWALK_CB_LOOPBACK
@ IDWALK_CB_HASH_IGNORE
@ IDWALK_CB_NEVER_SELF
@ IDWALK_CB_READFILE_IGNORE
VecBase< float, 3 > float3
IDProperty * IDP_CopyProperty_ex(const IDProperty *prop, int flag) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition idprop.cc:968
@ PROP_ACCELERATION
Definition RNA_types.hh:321
@ PROP_PERCENTAGE
Definition RNA_types.hh:307
@ PROP_TIME_ABSOLUTE
Definition RNA_types.hh:311
@ PROP_FACTOR
Definition RNA_types.hh:308
@ PROP_TRANSLATION
Definition RNA_types.hh:318
@ PROP_DISTANCE
Definition RNA_types.hh:313
@ PROP_VELOCITY
Definition RNA_types.hh:320
@ PROP_FILEPATH
Definition RNA_types.hh:284
@ PROP_FREQUENCY
Definition RNA_types.hh:349
@ PROP_COLOR_TEMPERATURE
Definition RNA_types.hh:347
@ PROP_WAVELENGTH
Definition RNA_types.hh:344
@ PROP_DIRECTION
Definition RNA_types.hh:319
@ PROP_UNSIGNED
Definition RNA_types.hh:306
GeometryNodeCurveResampleMode
void node_verify_sockets(Main *bmain, bNodeTree *ntree, bNode *node, bool do_id_user)
void id_us_min(ID *id)
Definition lib_id.cc:441
GeometryNodePointsToVolumeResolutionMode
GeometryNodeStringToCurvesOverflowMode
MINLINE void zero_v3_int(int r[3])
GeometryNodeStringToCurvesPivotMode
void BKE_ntree_update_tag_link_mute(bNodeTree *ntree, bNodeLink *link)
struct ID * BKE_id_copy_in_lib(Main *bmain, std::optional< Library * > owner_library, const ID *id, std::optional< const ID * > new_owner_id, ID **new_id_p, int flag)
Definition lib_id.cc:749
@ IDP_TYPE_FILTER_ID
void BLO_read_string(BlendDataReader *reader, char **ptr_p)
Definition readfile.cc:6653
size_t(*) MEM_allocN_len(const void *vmemh) ATTR_WARN_UNUSED_RESULT
void BKE_ntree_update_tag_node_internal_link(bNodeTree *ntree, bNode *node)
void uninitialized_copy_n(const T *src, int64_t n, T *dst)
signed short int16_t
Definition BKE_text.h:77
void BKE_ntree_update_tag_node_new(bNodeTree *ntree, bNode *node)
void BKE_libblock_free_data_py(ID *id)
@ IDTYPE_FLAGS_APPEND_IS_REUSABLE
Definition BKE_idtype.hh:50
#define hash
Definition noise_c.cc:156
The meta-data of an asset. By creating and giving this for a data-block (ID.asset_data),...
void write_string(const char *data)
void write_struct_by_name(const char *struct_name, const void *data, BlendStructWriterFn fn=nullptr)
void write_struct_at_address(const void *address, const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct_cast(const void *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
bool is_undo() const
void write_struct_array(const int64_t array_size, const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
char name[258]
Definition DNA_ID.h:433
struct Library * lib
Definition DNA_ID.h:421
short flag
Definition DNA_ID.h:439
struct AssetMetaData * asset_data
Definition DNA_ID.h:424
void * next
Definition DNA_ID.h:418
struct Scene * scene
ListBaseT< bNodeTree > nodetrees
Definition BKE_main.hh:409
ListBaseT< FreestyleLineStyle > linestyles
Definition BKE_main.hh:421
ListBaseT< Light > lights
Definition BKE_main.hh:396
ListBaseT< World > worlds
Definition BKE_main.hh:399
ListBaseT< Material > materials
Definition BKE_main.hh:392
ListBaseT< Scene > scenes
Definition BKE_main.hh:386
ListBaseT< Tex > textures
Definition BKE_main.hh:393
ListBaseT< CryptomatteLayer > layers
ListBaseT< CryptomatteEntry > entries
NodeCryptomatte_Runtime runtime
DNA_DEPRECATED char star_45
DNA_DEPRECATED char angle
DNA_DEPRECATED char streaks
DNA_DEPRECATED char type
DNA_DEPRECATED ImageFormatData format
DNA_DEPRECATED struct bNodeTree * nodetree
struct bNodeTree * nodetree
const bke::RuntimeNodeEnumItems * enum_items
bke::bNodeSocketType * typeinfo
eNodeSocketDatatype type
struct bNodeLink * link
bke::bNodeSocketRuntime * runtime
eNodeSocketInOut in_out
struct CompositorNodeAssetTraits * compositor_node_asset_traits
ListBaseT< bNodeLink > links
struct bGPdata * gpd
DNA_DEPRECATED ListBaseT< bNodeSocket > outputs_legacy
bke::bNodeTreeType * typeinfo
uint32_t next_node_identifier_seed
struct GeometryNodeAssetTraits * geometry_node_asset_traits
bNodeTreeInterface tree_interface
struct PreviewImage * preview
DNA_DEPRECATED ListBaseT< bNodeSocket > inputs_legacy
eNodeTree_Type type
bke::bNodeTreeRuntime * runtime
bNestedNodeRef * nested_node_refs
ListBaseT< bNode > nodes
struct bNode * parent
ListBaseT< bNodeSocket > outputs
bke::bNodeRuntime * runtime
bNodePanelState * panel_states_array
ListBaseT< bNodeSocket > inputs
bke::bNodeType * typeinfo
IDProperty * system_properties
struct bNode * next
IDProperty * prop
UString operator()(const T *value) const
Definition node.cc:2767
FreestyleLineStyle * linestyle
Definition BKE_node.hh:920
static constexpr int Default
Definition BKE_node.hh:253
Compact definition of a node socket.
Definition BKE_node.hh:102
Defines a socket type.
Definition BKE_node.hh:163
const CPPType * base_cpp_type
Definition BKE_node.hh:210
SocketGetCPPValueFunction get_base_cpp_value
Definition BKE_node.hh:212
void(*) free_self(bNodeSocketType *stype)
Definition BKE_node.hh:207
eNodeSocketDatatype type
Definition BKE_node.hh:198
void(*) localize(bNodeTree *localtree, bNodeTree *ntree)
Definition BKE_node.hh:561
Defines a node type.
Definition BKE_node.hh:265
NodeBlendWriteFunction blend_write_storage_content
Definition BKE_node.hh:421
std::string ui_description
Definition BKE_node.hh:271
NodeBlendDataReadFunction blend_data_read_storage_content
Definition BKE_node.hh:422
void(*) initfunc_api(const bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:333
bool(*) poll(const bNodeType *ntype, const bNodeTree *nodetree, const char **r_disabled_hint)
Definition BKE_node.hh:352
void(*) freefunc(bNode *node)
Definition BKE_node.hh:328
std::string storagename
Definition BKE_node.hh:287
bNodeSocketTemplate * inputs
Definition BKE_node.hh:285
void(*) copyfunc(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node)
Definition BKE_node.hh:330
bNodeSocketTemplate * outputs
Definition BKE_node.hh:285
void(*) initfunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:320
const char * enum_name_legacy
Definition BKE_node.hh:274
void(*) copyfunc_api(PointerRNA *ptr, const bNode *src_node)
Definition BKE_node.hh:335
NodeDeclareFunction declare
Definition BKE_node.hh:393
nodes::NodeDeclaration * static_declaration
Definition BKE_node.hh:402
void(*) free_self(bNodeType *ntype)
Definition BKE_node.hh:366
bool(*) poll_instance(const bNode *node, const bNodeTree *nodetree, const char **r_disabled_hint)
Definition BKE_node.hh:359
#define N_(msgid)