Geometry Nodes: new Material input node
[blender.git] / source / blender / blenkernel / intern / node.cc
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2005 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include "CLG_log.h"
25
26 #include "MEM_guardedalloc.h"
27
28 #include <climits>
29 #include <cstddef>
30 #include <cstdlib>
31 #include <cstring>
32
33 /* Allow using deprecated functionality for .blend file I/O. */
34 #define DNA_DEPRECATED_ALLOW
35
36 #include "DNA_action_types.h"
37 #include "DNA_anim_types.h"
38 #include "DNA_collection_types.h"
39 #include "DNA_gpencil_types.h"
40 #include "DNA_light_types.h"
41 #include "DNA_linestyle_types.h"
42 #include "DNA_material_types.h"
43 #include "DNA_modifier_types.h"
44 #include "DNA_node_types.h"
45 #include "DNA_scene_types.h"
46 #include "DNA_simulation_types.h"
47 #include "DNA_texture_types.h"
48 #include "DNA_world_types.h"
49
50 #include "BLI_ghash.h"
51 #include "BLI_listbase.h"
52 #include "BLI_map.hh"
53 #include "BLI_math.h"
54 #include "BLI_path_util.h"
55 #include "BLI_string.h"
56 #include "BLI_string_utils.h"
57 #include "BLI_utildefines.h"
58
59 #include "BLT_translation.h"
60
61 #include "BKE_anim_data.h"
62 #include "BKE_animsys.h"
63 #include "BKE_colortools.h"
64 #include "BKE_cryptomatte.h"
65 #include "BKE_global.h"
66 #include "BKE_idprop.h"
67 #include "BKE_idtype.h"
68 #include "BKE_lib_id.h"
69 #include "BKE_lib_query.h"
70 #include "BKE_main.h"
71 #include "BKE_node.h"
72 #include "BKE_node_ui_storage.hh"
73
74 #include "BLI_ghash.h"
75 #include "BLI_threads.h"
76 #include "RNA_access.h"
77 #include "RNA_define.h"
78
79 #include "NOD_common.h"
80 #include "NOD_composite.h"
81 #include "NOD_function.h"
82 #include "NOD_geometry.h"
83 #include "NOD_shader.h"
84 #include "NOD_socket.h"
85 #include "NOD_texture.h"
86
87 #include "DEG_depsgraph.h"
88 #include "DEG_depsgraph_build.h"
89
90 #include "BLO_read_write.h"
91
92 #include "MOD_nodes.h"
93
94 #define NODE_DEFAULT_MAX_WIDTH 700
95
96 /* Fallback types for undefined tree, nodes, sockets */
97 static bNodeTreeType NodeTreeTypeUndefined;
98 bNodeType NodeTypeUndefined;
99 bNodeSocketType NodeSocketTypeUndefined;
100
101 static CLG_LogRef LOG = {"bke.node"};
102
103 static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo);
104 static void node_socket_copy(bNodeSocket *sock_dst, const bNodeSocket *sock_src, const int flag);
105 static void free_localized_node_groups(bNodeTree *ntree);
106 static void node_free_node(bNodeTree *ntree, bNode *node);
107 static void node_socket_interface_free(bNodeTree *UNUSED(ntree),
108                                        bNodeSocket *sock,
109                                        const bool do_id_user);
110 static void nodeMuteRerouteOutputLinks(struct bNodeTree *ntree,
111                                        struct bNode *node,
112                                        const bool mute);
113
114 static void ntree_init_data(ID *id)
115 {
116   bNodeTree *ntree = (bNodeTree *)id;
117   ntree_set_typeinfo(ntree, nullptr);
118 }
119
120 static void ntree_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
121 {
122   bNodeTree *ntree_dst = (bNodeTree *)id_dst;
123   const bNodeTree *ntree_src = (const bNodeTree *)id_src;
124
125   /* We never handle usercount here for own data. */
126   const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
127
128   /* in case a running nodetree is copied */
129   ntree_dst->execdata = nullptr;
130
131   BLI_listbase_clear(&ntree_dst->nodes);
132   BLI_listbase_clear(&ntree_dst->links);
133
134   /* Since source nodes and sockets are unique pointers we can put everything in a single map. */
135   GHash *new_pointers = BLI_ghash_ptr_new(__func__);
136
137   LISTBASE_FOREACH (const bNode *, node_src, &ntree_src->nodes) {
138     bNode *new_node = BKE_node_copy_ex(ntree_dst, node_src, flag_subdata, true);
139     BLI_ghash_insert(new_pointers, (void *)node_src, new_node);
140     /* Store mapping to inputs. */
141     bNodeSocket *new_input_sock = (bNodeSocket *)new_node->inputs.first;
142     const bNodeSocket *input_sock_src = (const bNodeSocket *)node_src->inputs.first;
143     while (new_input_sock != nullptr) {
144       BLI_ghash_insert(new_pointers, (void *)input_sock_src, new_input_sock);
145       new_input_sock = new_input_sock->next;
146       input_sock_src = input_sock_src->next;
147     }
148     /* Store mapping to outputs. */
149     bNodeSocket *new_output_sock = (bNodeSocket *)new_node->outputs.first;
150     const bNodeSocket *output_sock_src = (const bNodeSocket *)node_src->outputs.first;
151     while (new_output_sock != nullptr) {
152       BLI_ghash_insert(new_pointers, (void *)output_sock_src, new_output_sock);
153       new_output_sock = new_output_sock->next;
154       output_sock_src = output_sock_src->next;
155     }
156   }
157
158   /* copy links */
159   BLI_duplicatelist(&ntree_dst->links, &ntree_src->links);
160   LISTBASE_FOREACH (bNodeLink *, link_dst, &ntree_dst->links) {
161     link_dst->fromnode = (bNode *)BLI_ghash_lookup_default(
162         new_pointers, link_dst->fromnode, nullptr);
163     link_dst->fromsock = (bNodeSocket *)BLI_ghash_lookup_default(
164         new_pointers, link_dst->fromsock, nullptr);
165     link_dst->tonode = (bNode *)BLI_ghash_lookup_default(new_pointers, link_dst->tonode, nullptr);
166     link_dst->tosock = (bNodeSocket *)BLI_ghash_lookup_default(
167         new_pointers, link_dst->tosock, nullptr);
168     /* update the link socket's pointer */
169     if (link_dst->tosock) {
170       link_dst->tosock->link = link_dst;
171     }
172   }
173
174   /* copy interface sockets */
175   BLI_duplicatelist(&ntree_dst->inputs, &ntree_src->inputs);
176   bNodeSocket *sock_dst, *sock_src;
177   for (sock_dst = (bNodeSocket *)ntree_dst->inputs.first,
178       sock_src = (bNodeSocket *)ntree_src->inputs.first;
179        sock_dst != nullptr;
180        sock_dst = (bNodeSocket *)sock_dst->next, sock_src = (bNodeSocket *)sock_src->next) {
181     node_socket_copy(sock_dst, sock_src, flag_subdata);
182   }
183
184   BLI_duplicatelist(&ntree_dst->outputs, &ntree_src->outputs);
185   for (sock_dst = (bNodeSocket *)ntree_dst->outputs.first,
186       sock_src = (bNodeSocket *)ntree_src->outputs.first;
187        sock_dst != nullptr;
188        sock_dst = (bNodeSocket *)sock_dst->next, sock_src = (bNodeSocket *)sock_src->next) {
189     node_socket_copy(sock_dst, sock_src, flag_subdata);
190   }
191
192   /* copy preview hash */
193   if (ntree_src->previews && (flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
194     bNodeInstanceHashIterator iter;
195
196     ntree_dst->previews = BKE_node_instance_hash_new("node previews");
197
198     NODE_INSTANCE_HASH_ITER (iter, ntree_src->previews) {
199       bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
200       bNodePreview *preview = (bNodePreview *)BKE_node_instance_hash_iterator_get_value(&iter);
201       BKE_node_instance_hash_insert(ntree_dst->previews, key, BKE_node_preview_copy(preview));
202     }
203   }
204   else {
205     ntree_dst->previews = nullptr;
206   }
207
208   /* update node->parent pointers */
209   for (bNode *node_dst = (bNode *)ntree_dst->nodes.first,
210              *node_src = (bNode *)ntree_src->nodes.first;
211        node_dst;
212        node_dst = (bNode *)node_dst->next, node_src = (bNode *)node_src->next) {
213     if (node_dst->parent) {
214       node_dst->parent = (bNode *)BLI_ghash_lookup_default(
215           new_pointers, node_dst->parent, nullptr);
216     }
217   }
218
219   BLI_ghash_free(new_pointers, nullptr, nullptr);
220
221   /* node tree will generate its own interface type */
222   ntree_dst->interface_type = nullptr;
223
224   /* Don't copy error messages in the runtime struct.
225    * They should be filled during execution anyway. */
226   ntree_dst->ui_storage = nullptr;
227 }
228
229 static void ntree_free_data(ID *id)
230 {
231   bNodeTree *ntree = (bNodeTree *)id;
232
233   /* XXX hack! node trees should not store execution graphs at all.
234    * This should be removed when old tree types no longer require it.
235    * Currently the execution data for texture nodes remains in the tree
236    * after execution, until the node tree is updated or freed.
237    */
238   if (ntree->execdata) {
239     switch (ntree->type) {
240       case NTREE_SHADER:
241         ntreeShaderEndExecTree(ntree->execdata);
242         break;
243       case NTREE_TEXTURE:
244         ntreeTexEndExecTree(ntree->execdata);
245         ntree->execdata = nullptr;
246         break;
247     }
248   }
249
250   /* XXX not nice, but needed to free localized node groups properly */
251   free_localized_node_groups(ntree);
252
253   /* unregister associated RNA types */
254   ntreeInterfaceTypeFree(ntree);
255
256   BLI_freelistN(&ntree->links); /* do first, then unlink_node goes fast */
257
258   LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) {
259     node_free_node(ntree, node);
260   }
261
262   /* free interface sockets */
263   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &ntree->inputs) {
264     node_socket_interface_free(ntree, sock, false);
265     MEM_freeN(sock);
266   }
267   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &ntree->outputs) {
268     node_socket_interface_free(ntree, sock, false);
269     MEM_freeN(sock);
270   }
271
272   /* free preview hash */
273   if (ntree->previews) {
274     BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
275   }
276
277   if (ntree->id.tag & LIB_TAG_LOCALIZED) {
278     BKE_libblock_free_data(&ntree->id, true);
279   }
280
281   delete ntree->ui_storage;
282 }
283
284 static void library_foreach_node_socket(LibraryForeachIDData *data, bNodeSocket *sock)
285 {
286   IDP_foreach_property(
287       sock->prop, IDP_TYPE_FILTER_ID, BKE_lib_query_idpropertiesForeachIDLink_callback, data);
288
289   switch ((eNodeSocketDatatype)sock->type) {
290     case SOCK_OBJECT: {
291       bNodeSocketValueObject *default_value = (bNodeSocketValueObject *)sock->default_value;
292       BKE_LIB_FOREACHID_PROCESS(data, default_value->value, IDWALK_CB_USER);
293       break;
294     }
295     case SOCK_IMAGE: {
296       bNodeSocketValueImage *default_value = (bNodeSocketValueImage *)sock->default_value;
297       BKE_LIB_FOREACHID_PROCESS(data, default_value->value, IDWALK_CB_USER);
298       break;
299     }
300     case SOCK_COLLECTION: {
301       bNodeSocketValueCollection *default_value = (bNodeSocketValueCollection *)
302                                                       sock->default_value;
303       BKE_LIB_FOREACHID_PROCESS(data, default_value->value, IDWALK_CB_USER);
304       break;
305     }
306     case SOCK_TEXTURE: {
307       bNodeSocketValueTexture *default_value = (bNodeSocketValueTexture *)sock->default_value;
308       BKE_LIB_FOREACHID_PROCESS(data, default_value->value, IDWALK_CB_USER);
309       break;
310     }
311     case SOCK_MATERIAL: {
312       bNodeSocketValueMaterial *default_value = (bNodeSocketValueMaterial *)sock->default_value;
313       BKE_LIB_FOREACHID_PROCESS(data, default_value->value, IDWALK_CB_USER);
314       break;
315     }
316     case SOCK_FLOAT:
317     case SOCK_VECTOR:
318     case SOCK_RGBA:
319     case SOCK_BOOLEAN:
320     case SOCK_INT:
321     case SOCK_STRING:
322     case __SOCK_MESH:
323     case SOCK_CUSTOM:
324     case SOCK_SHADER:
325     case SOCK_GEOMETRY:
326       break;
327   }
328 }
329
330 static void node_foreach_id(ID *id, LibraryForeachIDData *data)
331 {
332   bNodeTree *ntree = (bNodeTree *)id;
333
334   BKE_LIB_FOREACHID_PROCESS(data, ntree->gpd, IDWALK_CB_USER);
335
336   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
337     BKE_LIB_FOREACHID_PROCESS_ID(data, node->id, IDWALK_CB_USER);
338
339     IDP_foreach_property(
340         node->prop, IDP_TYPE_FILTER_ID, BKE_lib_query_idpropertiesForeachIDLink_callback, data);
341     LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
342       library_foreach_node_socket(data, sock);
343     }
344     LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
345       library_foreach_node_socket(data, sock);
346     }
347   }
348
349   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
350     library_foreach_node_socket(data, sock);
351   }
352   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
353     library_foreach_node_socket(data, sock);
354   }
355 }
356
357 static void node_foreach_cache(ID *id,
358                                IDTypeForeachCacheFunctionCallback function_callback,
359                                void *user_data)
360 {
361   bNodeTree *nodetree = (bNodeTree *)id;
362   IDCacheKey key = {0};
363   key.id_session_uuid = id->session_uuid;
364   key.offset_in_ID = offsetof(bNodeTree, previews);
365   key.cache_v = nodetree->previews;
366
367   /* TODO, see also `direct_link_nodetree()` in readfile.c. */
368 #if 0
369   function_callback(id, &key, (void **)&nodetree->previews, 0, user_data);
370 #endif
371
372   if (nodetree->type == NTREE_COMPOSIT) {
373     LISTBASE_FOREACH (bNode *, node, &nodetree->nodes) {
374       if (node->type == CMP_NODE_MOVIEDISTORTION) {
375         key.offset_in_ID = (size_t)BLI_ghashutil_strhash_p(node->name);
376         key.cache_v = node->storage;
377         function_callback(id, &key, (void **)&node->storage, 0, user_data);
378       }
379     }
380   }
381 }
382
383 static ID *node_owner_get(Main *bmain, ID *id)
384 {
385   if ((id->flag & LIB_EMBEDDED_DATA) == 0) {
386     return id;
387   }
388   /* TODO: Sort this NO_MAIN or not for embedded node trees. See T86119. */
389   // BLI_assert((id->tag & LIB_TAG_NO_MAIN) == 0);
390
391   ListBase *lists[] = {&bmain->materials,
392                        &bmain->lights,
393                        &bmain->worlds,
394                        &bmain->textures,
395                        &bmain->scenes,
396                        &bmain->linestyles,
397                        &bmain->simulations,
398                        nullptr};
399
400   bNodeTree *ntree = (bNodeTree *)id;
401   for (int i = 0; lists[i] != nullptr; i++) {
402     LISTBASE_FOREACH (ID *, id_iter, lists[i]) {
403       if (ntreeFromID(id_iter) == ntree) {
404         return id_iter;
405       }
406     }
407   }
408
409   BLI_assert(!"Embedded node tree with no owner. Critical Main inconsistency.");
410   return nullptr;
411 }
412
413 static void write_node_socket_default_value(BlendWriter *writer, bNodeSocket *sock)
414 {
415   if (sock->default_value == nullptr) {
416     return;
417   }
418
419   switch ((eNodeSocketDatatype)sock->type) {
420     case SOCK_FLOAT:
421       BLO_write_struct(writer, bNodeSocketValueFloat, sock->default_value);
422       break;
423     case SOCK_VECTOR:
424       BLO_write_struct(writer, bNodeSocketValueVector, sock->default_value);
425       break;
426     case SOCK_RGBA:
427       BLO_write_struct(writer, bNodeSocketValueRGBA, sock->default_value);
428       break;
429     case SOCK_BOOLEAN:
430       BLO_write_struct(writer, bNodeSocketValueBoolean, sock->default_value);
431       break;
432     case SOCK_INT:
433       BLO_write_struct(writer, bNodeSocketValueInt, sock->default_value);
434       break;
435     case SOCK_STRING:
436       BLO_write_struct(writer, bNodeSocketValueString, sock->default_value);
437       break;
438     case SOCK_OBJECT:
439       BLO_write_struct(writer, bNodeSocketValueObject, sock->default_value);
440       break;
441     case SOCK_IMAGE:
442       BLO_write_struct(writer, bNodeSocketValueImage, sock->default_value);
443       break;
444     case SOCK_COLLECTION:
445       BLO_write_struct(writer, bNodeSocketValueCollection, sock->default_value);
446       break;
447     case SOCK_TEXTURE:
448       BLO_write_struct(writer, bNodeSocketValueTexture, sock->default_value);
449       break;
450     case SOCK_MATERIAL:
451       BLO_write_struct(writer, bNodeSocketValueMaterial, sock->default_value);
452       break;
453     case __SOCK_MESH:
454     case SOCK_CUSTOM:
455     case SOCK_SHADER:
456     case SOCK_GEOMETRY:
457       BLI_assert_unreachable();
458       break;
459   }
460 }
461
462 static void write_node_socket(BlendWriter *writer, bNodeSocket *sock)
463 {
464   /* actual socket writing */
465   BLO_write_struct(writer, bNodeSocket, sock);
466
467   if (sock->prop) {
468     IDP_BlendWrite(writer, sock->prop);
469   }
470
471   write_node_socket_default_value(writer, sock);
472 }
473 static void write_node_socket_interface(BlendWriter *writer, bNodeSocket *sock)
474 {
475   /* actual socket writing */
476   BLO_write_struct(writer, bNodeSocket, sock);
477
478   if (sock->prop) {
479     IDP_BlendWrite(writer, sock->prop);
480   }
481
482   write_node_socket_default_value(writer, sock);
483 }
484
485 /* this is only direct data, tree itself should have been written */
486 void ntreeBlendWrite(BlendWriter *writer, bNodeTree *ntree)
487 {
488   BKE_id_blend_write(writer, &ntree->id);
489
490   /* for link_list() speed, we write per list */
491
492   if (ntree->adt) {
493     BKE_animdata_blend_write(writer, ntree->adt);
494   }
495
496   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
497     BLO_write_struct(writer, bNode, node);
498
499     if (node->prop) {
500       IDP_BlendWrite(writer, node->prop);
501     }
502
503     LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
504       write_node_socket(writer, sock);
505     }
506     LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
507       write_node_socket(writer, sock);
508     }
509
510     LISTBASE_FOREACH (bNodeLink *, link, &node->internal_links) {
511       BLO_write_struct(writer, bNodeLink, link);
512     }
513
514     if (node->storage) {
515       /* could be handlerized at some point, now only 1 exception still */
516       if ((ntree->type == NTREE_SHADER) &&
517           ELEM(node->type, SH_NODE_CURVE_VEC, SH_NODE_CURVE_RGB)) {
518         BKE_curvemapping_blend_write(writer, (const CurveMapping *)node->storage);
519       }
520       else if ((ntree->type == NTREE_GEOMETRY) && (node->type == GEO_NODE_ATTRIBUTE_CURVE_MAP)) {
521         BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
522         NodeAttributeCurveMap *data = (NodeAttributeCurveMap *)node->storage;
523         BKE_curvemapping_blend_write(writer, (const CurveMapping *)data->curve_vec);
524         BKE_curvemapping_blend_write(writer, (const CurveMapping *)data->curve_rgb);
525       }
526       else if (ntree->type == NTREE_SHADER && (node->type == SH_NODE_SCRIPT)) {
527         NodeShaderScript *nss = (NodeShaderScript *)node->storage;
528         if (nss->bytecode) {
529           BLO_write_string(writer, nss->bytecode);
530         }
531         BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
532       }
533       else if ((ntree->type == NTREE_COMPOSIT) && ELEM(node->type,
534                                                        CMP_NODE_TIME,
535                                                        CMP_NODE_CURVE_VEC,
536                                                        CMP_NODE_CURVE_RGB,
537                                                        CMP_NODE_HUECORRECT)) {
538         BKE_curvemapping_blend_write(writer, (const CurveMapping *)node->storage);
539       }
540       else if ((ntree->type == NTREE_TEXTURE) &&
541                (node->type == TEX_NODE_CURVE_RGB || node->type == TEX_NODE_CURVE_TIME)) {
542         BKE_curvemapping_blend_write(writer, (const CurveMapping *)node->storage);
543       }
544       else if ((ntree->type == NTREE_COMPOSIT) && (node->type == CMP_NODE_MOVIEDISTORTION)) {
545         /* pass */
546       }
547       else if ((ntree->type == NTREE_COMPOSIT) && (node->type == CMP_NODE_GLARE)) {
548         /* Simple forward compatibility for fix for T50736.
549          * Not ideal (there is no ideal solution here), but should do for now. */
550         NodeGlare *ndg = (NodeGlare *)node->storage;
551         /* Not in undo case. */
552         if (!BLO_write_is_undo(writer)) {
553           switch (ndg->type) {
554             case 2: /* Grrrr! magic numbers :( */
555               ndg->angle = ndg->streaks;
556               break;
557             case 0:
558               ndg->angle = ndg->star_45;
559               break;
560             default:
561               break;
562           }
563         }
564         BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
565       }
566       else if ((ntree->type == NTREE_COMPOSIT) &&
567                (ELEM(node->type, CMP_NODE_CRYPTOMATTE, CMP_NODE_CRYPTOMATTE_LEGACY))) {
568         NodeCryptomatte *nc = (NodeCryptomatte *)node->storage;
569         BLO_write_string(writer, nc->matte_id);
570         LISTBASE_FOREACH (CryptomatteEntry *, entry, &nc->entries) {
571           BLO_write_struct(writer, CryptomatteEntry, entry);
572         }
573         BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
574       }
575       else if (node->type == FN_NODE_INPUT_STRING) {
576         NodeInputString *storage = (NodeInputString *)node->storage;
577         if (storage->string) {
578           BLO_write_string(writer, storage->string);
579         }
580         BLO_write_struct_by_name(writer, node->typeinfo->storagename, storage);
581       }
582       else if (node->typeinfo != &NodeTypeUndefined) {
583         BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
584       }
585     }
586
587     if (node->type == CMP_NODE_OUTPUT_FILE) {
588       /* inputs have own storage data */
589       LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
590         BLO_write_struct(writer, NodeImageMultiFileSocket, sock->storage);
591       }
592     }
593     if (ELEM(node->type, CMP_NODE_IMAGE, CMP_NODE_R_LAYERS)) {
594       /* write extra socket info */
595       LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
596         BLO_write_struct(writer, NodeImageLayer, sock->storage);
597       }
598     }
599   }
600
601   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
602     BLO_write_struct(writer, bNodeLink, link);
603   }
604
605   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
606     write_node_socket_interface(writer, sock);
607   }
608   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
609     write_node_socket_interface(writer, sock);
610   }
611 }
612
613 static void ntree_blend_write(BlendWriter *writer, ID *id, const void *id_address)
614 {
615   bNodeTree *ntree = (bNodeTree *)id;
616   if (ntree->id.us > 0 || BLO_write_is_undo(writer)) {
617     /* Clean up, important in undo case to reduce false detection of changed datablocks. */
618     ntree->init = 0; /* to set callbacks and force setting types */
619     ntree->is_updating = false;
620     ntree->typeinfo = nullptr;
621     ntree->interface_type = nullptr;
622     ntree->progress = nullptr;
623     ntree->execdata = nullptr;
624     ntree->ui_storage = nullptr;
625
626     BLO_write_id_struct(writer, bNodeTree, id_address, &ntree->id);
627
628     ntreeBlendWrite(writer, ntree);
629   }
630 }
631
632 static void direct_link_node_socket(BlendDataReader *reader, bNodeSocket *sock)
633 {
634   BLO_read_data_address(reader, &sock->prop);
635   IDP_BlendDataRead(reader, &sock->prop);
636
637   BLO_read_data_address(reader, &sock->link);
638   sock->typeinfo = nullptr;
639   BLO_read_data_address(reader, &sock->storage);
640   BLO_read_data_address(reader, &sock->default_value);
641   sock->total_inputs = 0; /* Clear runtime data set before drawing. */
642   sock->cache = nullptr;
643 }
644
645 /* ntree itself has been read! */
646 void ntreeBlendReadData(BlendDataReader *reader, bNodeTree *ntree)
647 {
648   /* note: writing and reading goes in sync, for speed */
649   ntree->init = 0; /* to set callbacks and force setting types */
650   ntree->is_updating = false;
651   ntree->typeinfo = nullptr;
652   ntree->interface_type = nullptr;
653
654   ntree->progress = nullptr;
655   ntree->execdata = nullptr;
656   ntree->ui_storage = nullptr;
657
658   BLO_read_data_address(reader, &ntree->adt);
659   BKE_animdata_blend_read_data(reader, ntree->adt);
660
661   BLO_read_list(reader, &ntree->nodes);
662   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
663     node->typeinfo = nullptr;
664
665     BLO_read_list(reader, &node->inputs);
666     BLO_read_list(reader, &node->outputs);
667
668     BLO_read_data_address(reader, &node->prop);
669     IDP_BlendDataRead(reader, &node->prop);
670
671     BLO_read_list(reader, &node->internal_links);
672     LISTBASE_FOREACH (bNodeLink *, link, &node->internal_links) {
673       BLO_read_data_address(reader, &link->fromnode);
674       BLO_read_data_address(reader, &link->fromsock);
675       BLO_read_data_address(reader, &link->tonode);
676       BLO_read_data_address(reader, &link->tosock);
677     }
678
679     if (node->type == CMP_NODE_MOVIEDISTORTION) {
680       /* Do nothing, this is runtime cache and hence handled by generic code using
681        * `IDTypeInfo.foreach_cache` callback. */
682     }
683     else {
684       BLO_read_data_address(reader, &node->storage);
685     }
686
687     if (node->storage) {
688       /* could be handlerized at some point */
689       switch (node->type) {
690         case SH_NODE_CURVE_VEC:
691         case SH_NODE_CURVE_RGB:
692         case CMP_NODE_TIME:
693         case CMP_NODE_CURVE_VEC:
694         case CMP_NODE_CURVE_RGB:
695         case CMP_NODE_HUECORRECT:
696         case TEX_NODE_CURVE_RGB:
697         case TEX_NODE_CURVE_TIME: {
698           BKE_curvemapping_blend_read(reader, (CurveMapping *)node->storage);
699           break;
700         }
701         case GEO_NODE_ATTRIBUTE_CURVE_MAP: {
702           NodeAttributeCurveMap *data = (NodeAttributeCurveMap *)node->storage;
703           BLO_read_data_address(reader, &data->curve_vec);
704           if (data->curve_vec) {
705             BKE_curvemapping_blend_read(reader, data->curve_vec);
706           }
707           BLO_read_data_address(reader, &data->curve_rgb);
708           if (data->curve_rgb) {
709             BKE_curvemapping_blend_read(reader, data->curve_rgb);
710           }
711           break;
712         }
713         case SH_NODE_SCRIPT: {
714           NodeShaderScript *nss = (NodeShaderScript *)node->storage;
715           BLO_read_data_address(reader, &nss->bytecode);
716           break;
717         }
718         case SH_NODE_TEX_POINTDENSITY: {
719           NodeShaderTexPointDensity *npd = (NodeShaderTexPointDensity *)node->storage;
720           memset(&npd->pd, 0, sizeof(npd->pd));
721           break;
722         }
723         case SH_NODE_TEX_IMAGE: {
724           NodeTexImage *tex = (NodeTexImage *)node->storage;
725           tex->iuser.ok = 1;
726           tex->iuser.scene = nullptr;
727           break;
728         }
729         case SH_NODE_TEX_ENVIRONMENT: {
730           NodeTexEnvironment *tex = (NodeTexEnvironment *)node->storage;
731           tex->iuser.ok = 1;
732           tex->iuser.scene = nullptr;
733           break;
734         }
735         case CMP_NODE_IMAGE:
736         case CMP_NODE_R_LAYERS:
737         case CMP_NODE_VIEWER:
738         case CMP_NODE_SPLITVIEWER: {
739           ImageUser *iuser = (ImageUser *)node->storage;
740           iuser->ok = 1;
741           iuser->scene = nullptr;
742           break;
743         }
744         case CMP_NODE_CRYPTOMATTE_LEGACY:
745         case CMP_NODE_CRYPTOMATTE: {
746           NodeCryptomatte *nc = (NodeCryptomatte *)node->storage;
747           BLO_read_data_address(reader, &nc->matte_id);
748           BLO_read_list(reader, &nc->entries);
749           BLI_listbase_clear(&nc->runtime.layers);
750           break;
751         }
752         case TEX_NODE_IMAGE: {
753           ImageUser *iuser = (ImageUser *)node->storage;
754           iuser->ok = 1;
755           iuser->scene = nullptr;
756           break;
757         }
758         case FN_NODE_INPUT_STRING: {
759           NodeInputString *storage = (NodeInputString *)node->storage;
760           BLO_read_data_address(reader, &storage->string);
761           break;
762         }
763         default:
764           break;
765       }
766     }
767   }
768   BLO_read_list(reader, &ntree->links);
769
770   /* and we connect the rest */
771   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
772     BLO_read_data_address(reader, &node->parent);
773
774     LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
775       direct_link_node_socket(reader, sock);
776     }
777     LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
778       direct_link_node_socket(reader, sock);
779     }
780   }
781
782   /* interface socket lists */
783   BLO_read_list(reader, &ntree->inputs);
784   BLO_read_list(reader, &ntree->outputs);
785   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
786     direct_link_node_socket(reader, sock);
787   }
788   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
789     direct_link_node_socket(reader, sock);
790   }
791
792   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
793     BLO_read_data_address(reader, &link->fromnode);
794     BLO_read_data_address(reader, &link->tonode);
795     BLO_read_data_address(reader, &link->fromsock);
796     BLO_read_data_address(reader, &link->tosock);
797   }
798
799   /* TODO, should be dealt by new generic cache handling of IDs... */
800   ntree->previews = nullptr;
801
802   /* type verification is in lib-link */
803 }
804
805 static void ntree_blend_read_data(BlendDataReader *reader, ID *id)
806 {
807   bNodeTree *ntree = (bNodeTree *)id;
808   ntreeBlendReadData(reader, ntree);
809 }
810
811 static void lib_link_node_socket(BlendLibReader *reader, Library *lib, bNodeSocket *sock)
812 {
813   IDP_BlendReadLib(reader, sock->prop);
814
815   /* This can happen for all socket types when a file is saved in an older version of Blender than
816    * it was originally created in (T86298). Some socket types still require a default value. The
817    * default value of those sockets will be created in `ntreeSetTypes`. */
818   if (sock->default_value == nullptr) {
819     return;
820   }
821
822   switch ((eNodeSocketDatatype)sock->type) {
823     case SOCK_OBJECT: {
824       bNodeSocketValueObject *default_value = (bNodeSocketValueObject *)sock->default_value;
825       BLO_read_id_address(reader, lib, &default_value->value);
826       break;
827     }
828     case SOCK_IMAGE: {
829       bNodeSocketValueImage *default_value = (bNodeSocketValueImage *)sock->default_value;
830       BLO_read_id_address(reader, lib, &default_value->value);
831       break;
832     }
833     case SOCK_COLLECTION: {
834       bNodeSocketValueCollection *default_value = (bNodeSocketValueCollection *)
835                                                       sock->default_value;
836       BLO_read_id_address(reader, lib, &default_value->value);
837       break;
838     }
839     case SOCK_TEXTURE: {
840       bNodeSocketValueTexture *default_value = (bNodeSocketValueTexture *)sock->default_value;
841       BLO_read_id_address(reader, lib, &default_value->value);
842       break;
843     }
844     case SOCK_MATERIAL: {
845       bNodeSocketValueMaterial *default_value = (bNodeSocketValueMaterial *)sock->default_value;
846       BLO_read_id_address(reader, lib, &default_value->value);
847       break;
848     }
849     case SOCK_FLOAT:
850     case SOCK_VECTOR:
851     case SOCK_RGBA:
852     case SOCK_BOOLEAN:
853     case SOCK_INT:
854     case SOCK_STRING:
855     case __SOCK_MESH:
856     case SOCK_CUSTOM:
857     case SOCK_SHADER:
858     case SOCK_GEOMETRY:
859       break;
860   }
861 }
862
863 static void lib_link_node_sockets(BlendLibReader *reader, Library *lib, ListBase *sockets)
864 {
865   LISTBASE_FOREACH (bNodeSocket *, sock, sockets) {
866     lib_link_node_socket(reader, lib, sock);
867   }
868 }
869
870 void ntreeBlendReadLib(struct BlendLibReader *reader, struct bNodeTree *ntree)
871 {
872   Library *lib = ntree->id.lib;
873
874   BLO_read_id_address(reader, lib, &ntree->gpd);
875
876   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
877     /* Link ID Properties -- and copy this comment EXACTLY for easy finding
878      * of library blocks that implement this.*/
879     IDP_BlendReadLib(reader, node->prop);
880
881     BLO_read_id_address(reader, lib, &node->id);
882
883     lib_link_node_sockets(reader, lib, &node->inputs);
884     lib_link_node_sockets(reader, lib, &node->outputs);
885   }
886
887   lib_link_node_sockets(reader, lib, &ntree->inputs);
888   lib_link_node_sockets(reader, lib, &ntree->outputs);
889
890   /* Set node->typeinfo pointers. This is done in lib linking, after the
891    * first versioning that can change types still without functions that
892    * update the typeinfo pointers. Versioning after lib linking needs
893    * these top be valid. */
894   ntreeSetTypes(nullptr, ntree);
895
896   /* For nodes with static socket layout, add/remove sockets as needed
897    * to match the static layout. */
898   if (!BLO_read_lib_is_undo(reader)) {
899     LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
900       node_verify_socket_templates(ntree, node);
901     }
902   }
903 }
904
905 static void ntree_blend_read_lib(BlendLibReader *reader, ID *id)
906 {
907   bNodeTree *ntree = (bNodeTree *)id;
908   ntreeBlendReadLib(reader, ntree);
909 }
910
911 static void expand_node_socket(BlendExpander *expander, bNodeSocket *sock)
912 {
913   IDP_BlendReadExpand(expander, sock->prop);
914
915   if (sock->default_value != nullptr) {
916
917     switch ((eNodeSocketDatatype)sock->type) {
918       case SOCK_OBJECT: {
919         bNodeSocketValueObject *default_value = (bNodeSocketValueObject *)sock->default_value;
920         BLO_expand(expander, default_value->value);
921         break;
922       }
923       case SOCK_IMAGE: {
924         bNodeSocketValueImage *default_value = (bNodeSocketValueImage *)sock->default_value;
925         BLO_expand(expander, default_value->value);
926         break;
927       }
928       case SOCK_COLLECTION: {
929         bNodeSocketValueCollection *default_value = (bNodeSocketValueCollection *)
930                                                         sock->default_value;
931         BLO_expand(expander, default_value->value);
932         break;
933       }
934       case SOCK_TEXTURE: {
935         bNodeSocketValueTexture *default_value = (bNodeSocketValueTexture *)sock->default_value;
936         BLO_expand(expander, default_value->value);
937         break;
938       }
939       case SOCK_MATERIAL: {
940         bNodeSocketValueMaterial *default_value = (bNodeSocketValueMaterial *)sock->default_value;
941         BLO_expand(expander, default_value->value);
942         break;
943       }
944       case SOCK_FLOAT:
945       case SOCK_VECTOR:
946       case SOCK_RGBA:
947       case SOCK_BOOLEAN:
948       case SOCK_INT:
949       case SOCK_STRING:
950       case __SOCK_MESH:
951       case SOCK_CUSTOM:
952       case SOCK_SHADER:
953       case SOCK_GEOMETRY:
954         break;
955     }
956   }
957 }
958
959 static void expand_node_sockets(BlendExpander *expander, ListBase *sockets)
960 {
961   LISTBASE_FOREACH (bNodeSocket *, sock, sockets) {
962     expand_node_socket(expander, sock);
963   }
964 }
965
966 void ntreeBlendReadExpand(BlendExpander *expander, bNodeTree *ntree)
967 {
968   if (ntree->gpd) {
969     BLO_expand(expander, ntree->gpd);
970   }
971
972   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
973     if (node->id && !(node->type == CMP_NODE_R_LAYERS) &&
974         !(node->type == CMP_NODE_CRYPTOMATTE && node->custom1 == CMP_CRYPTOMATTE_SRC_RENDER)) {
975       BLO_expand(expander, node->id);
976     }
977
978     IDP_BlendReadExpand(expander, node->prop);
979
980     expand_node_sockets(expander, &node->inputs);
981     expand_node_sockets(expander, &node->outputs);
982   }
983
984   expand_node_sockets(expander, &ntree->inputs);
985   expand_node_sockets(expander, &ntree->outputs);
986 }
987
988 static void ntree_blend_read_expand(BlendExpander *expander, ID *id)
989 {
990   bNodeTree *ntree = (bNodeTree *)id;
991   ntreeBlendReadExpand(expander, ntree);
992 }
993
994 IDTypeInfo IDType_ID_NT = {
995     /* id_code */ ID_NT,
996     /* id_filter */ FILTER_ID_NT,
997     /* main_listbase_index */ INDEX_ID_NT,
998     /* struct_size */ sizeof(bNodeTree),
999     /* name */ "NodeTree",
1000     /* name_plural */ "node_groups",
1001     /* translation_context */ BLT_I18NCONTEXT_ID_NODETREE,
1002     /* flags */ 0,
1003
1004     /* init_data */ ntree_init_data,
1005     /* copy_data */ ntree_copy_data,
1006     /* free_data */ ntree_free_data,
1007     /* make_local */ nullptr,
1008     /* foreach_id */ node_foreach_id,
1009     /* foreach_cache */ node_foreach_cache,
1010     /* owner_get */ node_owner_get,
1011
1012     /* blend_write */ ntree_blend_write,
1013     /* blend_read_data */ ntree_blend_read_data,
1014     /* blend_read_lib */ ntree_blend_read_lib,
1015     /* blend_read_expand */ ntree_blend_read_expand,
1016
1017     /* blend_read_undo_preserve */ nullptr,
1018
1019     /* lib_override_apply_post */ nullptr,
1020 };
1021
1022 static void node_add_sockets_from_type(bNodeTree *ntree, bNode *node, bNodeType *ntype)
1023 {
1024   bNodeSocketTemplate *sockdef;
1025   /* bNodeSocket *sock; */ /* UNUSED */
1026
1027   if (ntype->inputs) {
1028     sockdef = ntype->inputs;
1029     while (sockdef->type != -1) {
1030       /* sock = */ node_add_socket_from_template(ntree, node, sockdef, SOCK_IN);
1031
1032       sockdef++;
1033     }
1034   }
1035   if (ntype->outputs) {
1036     sockdef = ntype->outputs;
1037     while (sockdef->type != -1) {
1038       /* sock = */ node_add_socket_from_template(ntree, node, sockdef, SOCK_OUT);
1039
1040       sockdef++;
1041     }
1042   }
1043 }
1044
1045 /* Note: This function is called to initialize node data based on the type.
1046  * The bNodeType may not be registered at creation time of the node,
1047  * so this can be delayed until the node type gets registered.
1048  */
1049 static void node_init(const struct bContext *C, bNodeTree *ntree, bNode *node)
1050 {
1051   bNodeType *ntype = node->typeinfo;
1052   if (ntype == &NodeTypeUndefined) {
1053     return;
1054   }
1055
1056   /* only do this once */
1057   if (node->flag & NODE_INIT) {
1058     return;
1059   }
1060
1061   node->flag = NODE_SELECT | NODE_OPTIONS | ntype->flag;
1062   node->width = ntype->width;
1063   node->miniwidth = 42.0f;
1064   node->height = ntype->height;
1065   node->color[0] = node->color[1] = node->color[2] = 0.608; /* default theme color */
1066   /* initialize the node name with the node label.
1067    * note: do this after the initfunc so nodes get their data set which may be used in naming
1068    * (node groups for example) */
1069   /* XXX Do not use nodeLabel() here, it returns translated content for UI,
1070    *     which should *only* be used in UI, *never* in data...
1071    *     Data have their own translation option!
1072    *     This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler
1073    *     than adding "do_translate" flags to this func (and labelfunc() as well). */
1074   BLI_strncpy(node->name, DATA_(ntype->ui_name), NODE_MAXSTR);
1075   nodeUniqueName(ntree, node);
1076
1077   node_add_sockets_from_type(ntree, node, ntype);
1078
1079   if (ntype->initfunc != nullptr) {
1080     ntype->initfunc(ntree, node);
1081   }
1082
1083   if (ntree->typeinfo->node_add_init != nullptr) {
1084     ntree->typeinfo->node_add_init(ntree, node);
1085   }
1086
1087   if (node->id) {
1088     id_us_plus(node->id);
1089   }
1090
1091   /* extra init callback */
1092   if (ntype->initfunc_api) {
1093     PointerRNA ptr;
1094     RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
1095
1096     /* XXX Warning: context can be nullptr in case nodes are added in do_versions.
1097      * Delayed init is not supported for nodes with context-based initfunc_api atm.
1098      */
1099     BLI_assert(C != nullptr);
1100     ntype->initfunc_api(C, &ptr);
1101   }
1102
1103   node->flag |= NODE_INIT;
1104 }
1105
1106 static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo)
1107 {
1108   if (typeinfo) {
1109     ntree->typeinfo = typeinfo;
1110
1111     /* deprecated integer type */
1112     ntree->type = typeinfo->type;
1113   }
1114   else {
1115     ntree->typeinfo = &NodeTreeTypeUndefined;
1116
1117     ntree->init &= ~NTREE_TYPE_INIT;
1118   }
1119 }
1120
1121 static void node_set_typeinfo(const struct bContext *C,
1122                               bNodeTree *ntree,
1123                               bNode *node,
1124                               bNodeType *typeinfo)
1125 {
1126   /* for nodes saved in older versions storage can get lost, make undefined then */
1127   if (node->flag & NODE_INIT) {
1128     if (typeinfo && typeinfo->storagename[0] && !node->storage) {
1129       typeinfo = nullptr;
1130     }
1131   }
1132
1133   if (typeinfo) {
1134     node->typeinfo = typeinfo;
1135
1136     /* deprecated integer type */
1137     node->type = typeinfo->type;
1138
1139     /* initialize the node if necessary */
1140     node_init(C, ntree, node);
1141   }
1142   else {
1143     node->typeinfo = &NodeTypeUndefined;
1144
1145     ntree->init &= ~NTREE_TYPE_INIT;
1146   }
1147 }
1148
1149 static void node_socket_set_typeinfo(bNodeTree *ntree,
1150                                      bNodeSocket *sock,
1151                                      bNodeSocketType *typeinfo)
1152 {
1153   if (typeinfo) {
1154     sock->typeinfo = typeinfo;
1155
1156     /* deprecated integer type */
1157     sock->type = typeinfo->type;
1158
1159     if (sock->default_value == nullptr) {
1160       /* initialize the default_value pointer used by standard socket types */
1161       node_socket_init_default_value(sock);
1162     }
1163   }
1164   else {
1165     sock->typeinfo = &NodeSocketTypeUndefined;
1166
1167     ntree->init &= ~NTREE_TYPE_INIT;
1168   }
1169 }
1170
1171 /* Set specific typeinfo pointers in all node trees on register/unregister */
1172 static void update_typeinfo(Main *bmain,
1173                             const struct bContext *C,
1174                             bNodeTreeType *treetype,
1175                             bNodeType *nodetype,
1176                             bNodeSocketType *socktype,
1177                             bool unregister)
1178 {
1179   if (!bmain) {
1180     return;
1181   }
1182
1183   FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1184     ntree->init |= NTREE_TYPE_INIT;
1185
1186     if (treetype && STREQ(ntree->idname, treetype->idname)) {
1187       ntree_set_typeinfo(ntree, unregister ? nullptr : treetype);
1188     }
1189
1190     /* initialize nodes */
1191     LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1192       if (nodetype && STREQ(node->idname, nodetype->idname)) {
1193         node_set_typeinfo(C, ntree, node, unregister ? nullptr : nodetype);
1194       }
1195
1196       /* initialize node sockets */
1197       LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
1198         if (socktype && STREQ(sock->idname, socktype->idname)) {
1199           node_socket_set_typeinfo(ntree, sock, unregister ? nullptr : socktype);
1200         }
1201       }
1202       LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
1203         if (socktype && STREQ(sock->idname, socktype->idname)) {
1204           node_socket_set_typeinfo(ntree, sock, unregister ? nullptr : socktype);
1205         }
1206       }
1207     }
1208
1209     /* initialize tree sockets */
1210     LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
1211       if (socktype && STREQ(sock->idname, socktype->idname)) {
1212         node_socket_set_typeinfo(ntree, sock, unregister ? nullptr : socktype);
1213       }
1214     }
1215     LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
1216       if (socktype && STREQ(sock->idname, socktype->idname)) {
1217         node_socket_set_typeinfo(ntree, sock, unregister ? nullptr : socktype);
1218       }
1219     }
1220   }
1221   FOREACH_NODETREE_END;
1222 }
1223
1224 /* Try to initialize all typeinfo in a node tree.
1225  * NB: In general undefined typeinfo is a perfectly valid case,
1226  * the type may just be registered later.
1227  * In that case the update_typeinfo function will set typeinfo on registration
1228  * and do necessary updates.
1229  */
1230 void ntreeSetTypes(const struct bContext *C, bNodeTree *ntree)
1231 {
1232   ntree->init |= NTREE_TYPE_INIT;
1233
1234   ntree_set_typeinfo(ntree, ntreeTypeFind(ntree->idname));
1235
1236   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1237     node_set_typeinfo(C, ntree, node, nodeTypeFind(node->idname));
1238
1239     LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
1240       node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
1241     }
1242     LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
1243       node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
1244     }
1245   }
1246
1247   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
1248     node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
1249   }
1250   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
1251     node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
1252   }
1253 }
1254
1255 static GHash *nodetreetypes_hash = nullptr;
1256 static GHash *nodetypes_hash = nullptr;
1257 static GHash *nodesockettypes_hash = nullptr;
1258
1259 bNodeTreeType *ntreeTypeFind(const char *idname)
1260 {
1261   if (idname[0]) {
1262     bNodeTreeType *nt = (bNodeTreeType *)BLI_ghash_lookup(nodetreetypes_hash, idname);
1263     if (nt) {
1264       return nt;
1265     }
1266   }
1267
1268   return nullptr;
1269 }
1270
1271 void ntreeTypeAdd(bNodeTreeType *nt)
1272 {
1273   BLI_ghash_insert(nodetreetypes_hash, nt->idname, nt);
1274   /* XXX pass Main to register function? */
1275   /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1276    * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1277   update_typeinfo(G_MAIN, nullptr, nt, nullptr, nullptr, false);
1278 }
1279
1280 /* callback for hash value free function */
1281 static void ntree_free_type(void *treetype_v)
1282 {
1283   bNodeTreeType *treetype = (bNodeTreeType *)treetype_v;
1284   /* XXX pass Main to unregister function? */
1285   /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1286    * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1287   update_typeinfo(G_MAIN, nullptr, treetype, nullptr, nullptr, true);
1288   MEM_freeN(treetype);
1289 }
1290
1291 void ntreeTypeFreeLink(const bNodeTreeType *nt)
1292 {
1293   BLI_ghash_remove(nodetreetypes_hash, nt->idname, nullptr, ntree_free_type);
1294 }
1295
1296 bool ntreeIsRegistered(bNodeTree *ntree)
1297 {
1298   return (ntree->typeinfo != &NodeTreeTypeUndefined);
1299 }
1300
1301 GHashIterator *ntreeTypeGetIterator(void)
1302 {
1303   return BLI_ghashIterator_new(nodetreetypes_hash);
1304 }
1305
1306 bNodeType *nodeTypeFind(const char *idname)
1307 {
1308   if (idname[0]) {
1309     bNodeType *nt = (bNodeType *)BLI_ghash_lookup(nodetypes_hash, idname);
1310     if (nt) {
1311       return nt;
1312     }
1313   }
1314
1315   return nullptr;
1316 }
1317
1318 static void free_dynamic_typeinfo(bNodeType *ntype)
1319 {
1320   if (ntype->type == NODE_DYNAMIC) {
1321     if (ntype->inputs) {
1322       MEM_freeN(ntype->inputs);
1323     }
1324     if (ntype->outputs) {
1325       MEM_freeN(ntype->outputs);
1326     }
1327   }
1328 }
1329
1330 /* callback for hash value free function */
1331 static void node_free_type(void *nodetype_v)
1332 {
1333   bNodeType *nodetype = (bNodeType *)nodetype_v;
1334   /* XXX pass Main to unregister function? */
1335   /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1336    * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1337   update_typeinfo(G_MAIN, nullptr, nullptr, nodetype, nullptr, true);
1338
1339   /* XXX deprecated */
1340   if (nodetype->type == NODE_DYNAMIC) {
1341     free_dynamic_typeinfo(nodetype);
1342   }
1343
1344   /* Can be null when the type is not dynamically allocated. */
1345   if (nodetype->free_self) {
1346     nodetype->free_self(nodetype);
1347   }
1348 }
1349
1350 void nodeRegisterType(bNodeType *nt)
1351 {
1352   /* debug only: basic verification of registered types */
1353   BLI_assert(nt->idname[0] != '\0');
1354   BLI_assert(nt->poll != nullptr);
1355
1356   BLI_ghash_insert(nodetypes_hash, nt->idname, nt);
1357   /* XXX pass Main to register function? */
1358   /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1359    * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1360   update_typeinfo(G_MAIN, nullptr, nullptr, nt, nullptr, false);
1361 }
1362
1363 void nodeUnregisterType(bNodeType *nt)
1364 {
1365   BLI_ghash_remove(nodetypes_hash, nt->idname, nullptr, node_free_type);
1366 }
1367
1368 bool nodeTypeUndefined(bNode *node)
1369 {
1370   return (node->typeinfo == &NodeTypeUndefined) ||
1371          ((node->type == NODE_GROUP || node->type == NODE_CUSTOM_GROUP) && node->id &&
1372           ID_IS_LINKED(node->id) && (node->id->tag & LIB_TAG_MISSING));
1373 }
1374
1375 GHashIterator *nodeTypeGetIterator(void)
1376 {
1377   return BLI_ghashIterator_new(nodetypes_hash);
1378 }
1379
1380 bNodeSocketType *nodeSocketTypeFind(const char *idname)
1381 {
1382   if (idname[0]) {
1383     bNodeSocketType *st = (bNodeSocketType *)BLI_ghash_lookup(nodesockettypes_hash, idname);
1384     if (st) {
1385       return st;
1386     }
1387   }
1388
1389   return nullptr;
1390 }
1391
1392 /* callback for hash value free function */
1393 static void node_free_socket_type(void *socktype_v)
1394 {
1395   bNodeSocketType *socktype = (bNodeSocketType *)socktype_v;
1396   /* XXX pass Main to unregister function? */
1397   /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1398    * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1399   update_typeinfo(G_MAIN, nullptr, nullptr, nullptr, socktype, true);
1400
1401   socktype->free_self(socktype);
1402 }
1403
1404 void nodeRegisterSocketType(bNodeSocketType *st)
1405 {
1406   BLI_ghash_insert(nodesockettypes_hash, (void *)st->idname, st);
1407   /* XXX pass Main to register function? */
1408   /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1409    * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1410   update_typeinfo(G_MAIN, nullptr, nullptr, nullptr, st, false);
1411 }
1412
1413 void nodeUnregisterSocketType(bNodeSocketType *st)
1414 {
1415   BLI_ghash_remove(nodesockettypes_hash, st->idname, nullptr, node_free_socket_type);
1416 }
1417
1418 bool nodeSocketIsRegistered(bNodeSocket *sock)
1419 {
1420   return (sock->typeinfo != &NodeSocketTypeUndefined);
1421 }
1422
1423 GHashIterator *nodeSocketTypeGetIterator(void)
1424 {
1425   return BLI_ghashIterator_new(nodesockettypes_hash);
1426 }
1427
1428 struct bNodeSocket *nodeFindSocket(const bNode *node,
1429                                    eNodeSocketInOut in_out,
1430                                    const char *identifier)
1431 {
1432   const ListBase *sockets = (in_out == SOCK_IN) ? &node->inputs : &node->outputs;
1433   LISTBASE_FOREACH (bNodeSocket *, sock, sockets) {
1434     if (STREQ(sock->identifier, identifier)) {
1435       return sock;
1436     }
1437   }
1438   return nullptr;
1439 }
1440
1441 /* find unique socket identifier */
1442 static bool unique_identifier_check(void *arg, const char *identifier)
1443 {
1444   const ListBase *lb = (const ListBase *)arg;
1445   LISTBASE_FOREACH (bNodeSocket *, sock, lb) {
1446     if (STREQ(sock->identifier, identifier)) {
1447       return true;
1448     }
1449   }
1450   return false;
1451 }
1452
1453 static bNodeSocket *make_socket(bNodeTree *ntree,
1454                                 bNode *UNUSED(node),
1455                                 int in_out,
1456                                 ListBase *lb,
1457                                 const char *idname,
1458                                 const char *identifier,
1459                                 const char *name)
1460 {
1461   char auto_identifier[MAX_NAME];
1462
1463   if (identifier && identifier[0] != '\0') {
1464     /* use explicit identifier */
1465     BLI_strncpy(auto_identifier, identifier, sizeof(auto_identifier));
1466   }
1467   else {
1468     /* if no explicit identifier is given, assign a unique identifier based on the name */
1469     BLI_strncpy(auto_identifier, name, sizeof(auto_identifier));
1470   }
1471   /* make the identifier unique */
1472   BLI_uniquename_cb(
1473       unique_identifier_check, lb, "socket", '.', auto_identifier, sizeof(auto_identifier));
1474
1475   bNodeSocket *sock = (bNodeSocket *)MEM_callocN(sizeof(bNodeSocket), "sock");
1476   sock->in_out = in_out;
1477
1478   BLI_strncpy(sock->identifier, auto_identifier, NODE_MAXSTR);
1479   sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
1480
1481   BLI_strncpy(sock->name, name, NODE_MAXSTR);
1482   sock->storage = nullptr;
1483   sock->flag |= SOCK_COLLAPSED;
1484   sock->type = SOCK_CUSTOM; /* int type undefined by default */
1485
1486   BLI_strncpy(sock->idname, idname, sizeof(sock->idname));
1487   node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(idname));
1488
1489   return sock;
1490 }
1491
1492 static void socket_id_user_increment(bNodeSocket *sock)
1493 {
1494   switch ((eNodeSocketDatatype)sock->type) {
1495     case SOCK_OBJECT: {
1496       bNodeSocketValueObject *default_value = (bNodeSocketValueObject *)sock->default_value;
1497       id_us_plus((ID *)default_value->value);
1498       break;
1499     }
1500     case SOCK_IMAGE: {
1501       bNodeSocketValueImage *default_value = (bNodeSocketValueImage *)sock->default_value;
1502       id_us_plus((ID *)default_value->value);
1503       break;
1504     }
1505     case SOCK_COLLECTION: {
1506       bNodeSocketValueCollection *default_value = (bNodeSocketValueCollection *)
1507                                                       sock->default_value;
1508       id_us_plus((ID *)default_value->value);
1509       break;
1510     }
1511     case SOCK_TEXTURE: {
1512       bNodeSocketValueTexture *default_value = (bNodeSocketValueTexture *)sock->default_value;
1513       id_us_plus((ID *)default_value->value);
1514       break;
1515     }
1516     case SOCK_MATERIAL: {
1517       bNodeSocketValueMaterial *default_value = (bNodeSocketValueMaterial *)sock->default_value;
1518       id_us_plus((ID *)default_value->value);
1519       break;
1520     }
1521     case SOCK_FLOAT:
1522     case SOCK_VECTOR:
1523     case SOCK_RGBA:
1524     case SOCK_BOOLEAN:
1525     case SOCK_INT:
1526     case SOCK_STRING:
1527     case __SOCK_MESH:
1528     case SOCK_CUSTOM:
1529     case SOCK_SHADER:
1530     case SOCK_GEOMETRY:
1531       break;
1532   }
1533 }
1534
1535 static void socket_id_user_decrement(bNodeSocket *sock)
1536 {
1537   switch ((eNodeSocketDatatype)sock->type) {
1538     case SOCK_OBJECT: {
1539       bNodeSocketValueObject *default_value = (bNodeSocketValueObject *)sock->default_value;
1540       if (default_value->value != nullptr) {
1541         id_us_min(&default_value->value->id);
1542       }
1543       break;
1544     }
1545     case SOCK_IMAGE: {
1546       bNodeSocketValueImage *default_value = (bNodeSocketValueImage *)sock->default_value;
1547       if (default_value->value != nullptr) {
1548         id_us_min(&default_value->value->id);
1549       }
1550       break;
1551     }
1552     case SOCK_COLLECTION: {
1553       bNodeSocketValueCollection *default_value = (bNodeSocketValueCollection *)
1554                                                       sock->default_value;
1555       if (default_value->value != nullptr) {
1556         id_us_min(&default_value->value->id);
1557       }
1558       break;
1559     }
1560     case SOCK_TEXTURE: {
1561       bNodeSocketValueTexture *default_value = (bNodeSocketValueTexture *)sock->default_value;
1562       if (default_value->value != nullptr) {
1563         id_us_min(&default_value->value->id);
1564       }
1565       break;
1566     }
1567     case SOCK_MATERIAL: {
1568       bNodeSocketValueMaterial *default_value = (bNodeSocketValueMaterial *)sock->default_value;
1569       if (default_value->value != nullptr) {
1570         id_us_min(&default_value->value->id);
1571       }
1572       break;
1573     }
1574     case SOCK_FLOAT:
1575     case SOCK_VECTOR:
1576     case SOCK_RGBA:
1577     case SOCK_BOOLEAN:
1578     case SOCK_INT:
1579     case SOCK_STRING:
1580     case __SOCK_MESH:
1581     case SOCK_CUSTOM:
1582     case SOCK_SHADER:
1583     case SOCK_GEOMETRY:
1584       break;
1585   }
1586 }
1587
1588 void nodeModifySocketType(
1589     bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, int type, int subtype)
1590 {
1591   const char *idname = nodeStaticSocketType(type, subtype);
1592
1593   if (!idname) {
1594     CLOG_ERROR(&LOG, "static node socket type %d undefined", type);
1595     return;
1596   }
1597
1598   if (sock->default_value) {
1599     socket_id_user_decrement(sock);
1600     MEM_freeN(sock->default_value);
1601     sock->default_value = nullptr;
1602   }
1603
1604   sock->type = type;
1605   BLI_strncpy(sock->idname, idname, sizeof(sock->idname));
1606   node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(idname));
1607 }
1608
1609 bNodeSocket *nodeAddSocket(bNodeTree *ntree,
1610                            bNode *node,
1611                            eNodeSocketInOut in_out,
1612                            const char *idname,
1613                            const char *identifier,
1614                            const char *name)
1615 {
1616   BLI_assert(node->type != NODE_FRAME);
1617   BLI_assert(!(in_out == SOCK_IN && node->type == NODE_GROUP_INPUT));
1618   BLI_assert(!(in_out == SOCK_OUT && node->type == NODE_GROUP_OUTPUT));
1619
1620   ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs);
1621   bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name);
1622
1623   BLI_remlink(lb, sock); /* does nothing for new socket */
1624   BLI_addtail(lb, sock);
1625
1626   node->update |= NODE_UPDATE;
1627
1628   return sock;
1629 }
1630
1631 bNodeSocket *nodeInsertSocket(bNodeTree *ntree,
1632                               bNode *node,
1633                               eNodeSocketInOut in_out,
1634                               const char *idname,
1635                               bNodeSocket *next_sock,
1636                               const char *identifier,
1637                               const char *name)
1638 {
1639   ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs);
1640   bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name);
1641
1642   BLI_remlink(lb, sock); /* does nothing for new socket */
1643   BLI_insertlinkbefore(lb, next_sock, sock);
1644
1645   node->update |= NODE_UPDATE;
1646
1647   return sock;
1648 }
1649
1650 const char *nodeStaticSocketType(int type, int subtype)
1651 {
1652   switch (type) {
1653     case SOCK_FLOAT:
1654       switch (subtype) {
1655         case PROP_UNSIGNED:
1656           return "NodeSocketFloatUnsigned";
1657         case PROP_PERCENTAGE:
1658           return "NodeSocketFloatPercentage";
1659         case PROP_FACTOR:
1660           return "NodeSocketFloatFactor";
1661         case PROP_ANGLE:
1662           return "NodeSocketFloatAngle";
1663         case PROP_TIME:
1664           return "NodeSocketFloatTime";
1665         case PROP_DISTANCE:
1666           return "NodeSocketFloatDistance";
1667         case PROP_NONE:
1668         default:
1669           return "NodeSocketFloat";
1670       }
1671     case SOCK_INT:
1672       switch (subtype) {
1673         case PROP_UNSIGNED:
1674           return "NodeSocketIntUnsigned";
1675         case PROP_PERCENTAGE:
1676           return "NodeSocketIntPercentage";
1677         case PROP_FACTOR:
1678           return "NodeSocketIntFactor";
1679         case PROP_NONE:
1680         default:
1681           return "NodeSocketInt";
1682       }
1683     case SOCK_BOOLEAN:
1684       return "NodeSocketBool";
1685     case SOCK_VECTOR:
1686       switch (subtype) {
1687         case PROP_TRANSLATION:
1688           return "NodeSocketVectorTranslation";
1689         case PROP_DIRECTION:
1690           return "NodeSocketVectorDirection";
1691         case PROP_VELOCITY:
1692           return "NodeSocketVectorVelocity";
1693         case PROP_ACCELERATION:
1694           return "NodeSocketVectorAcceleration";
1695         case PROP_EULER:
1696           return "NodeSocketVectorEuler";
1697         case PROP_XYZ:
1698           return "NodeSocketVectorXYZ";
1699         case PROP_NONE:
1700         default:
1701           return "NodeSocketVector";
1702       }
1703     case SOCK_RGBA:
1704       return "NodeSocketColor";
1705     case SOCK_STRING:
1706       return "NodeSocketString";
1707     case SOCK_SHADER:
1708       return "NodeSocketShader";
1709     case SOCK_OBJECT:
1710       return "NodeSocketObject";
1711     case SOCK_IMAGE:
1712       return "NodeSocketImage";
1713     case SOCK_GEOMETRY:
1714       return "NodeSocketGeometry";
1715     case SOCK_COLLECTION:
1716       return "NodeSocketCollection";
1717     case SOCK_TEXTURE:
1718       return "NodeSocketTexture";
1719     case SOCK_MATERIAL:
1720       return "NodeSocketMaterial";
1721   }
1722   return nullptr;
1723 }
1724
1725 const char *nodeStaticSocketInterfaceType(int type, int subtype)
1726 {
1727   switch (type) {
1728     case SOCK_FLOAT:
1729       switch (subtype) {
1730         case PROP_UNSIGNED:
1731           return "NodeSocketInterfaceFloatUnsigned";
1732         case PROP_PERCENTAGE:
1733           return "NodeSocketInterfaceFloatPercentage";
1734         case PROP_FACTOR:
1735           return "NodeSocketInterfaceFloatFactor";
1736         case PROP_ANGLE:
1737           return "NodeSocketInterfaceFloatAngle";
1738         case PROP_TIME:
1739           return "NodeSocketInterfaceFloatTime";
1740         case PROP_DISTANCE:
1741           return "NodeSocketInterfaceFloatDistance";
1742         case PROP_NONE:
1743         default:
1744           return "NodeSocketInterfaceFloat";
1745       }
1746     case SOCK_INT:
1747       switch (subtype) {
1748         case PROP_UNSIGNED:
1749           return "NodeSocketInterfaceIntUnsigned";
1750         case PROP_PERCENTAGE:
1751           return "NodeSocketInterfaceIntPercentage";
1752         case PROP_FACTOR:
1753           return "NodeSocketInterfaceIntFactor";
1754         case PROP_NONE:
1755         default:
1756           return "NodeSocketInterfaceInt";
1757       }
1758     case SOCK_BOOLEAN:
1759       return "NodeSocketInterfaceBool";
1760     case SOCK_VECTOR:
1761       switch (subtype) {
1762         case PROP_TRANSLATION:
1763           return "NodeSocketInterfaceVectorTranslation";
1764         case PROP_DIRECTION:
1765           return "NodeSocketInterfaceVectorDirection";
1766         case PROP_VELOCITY:
1767           return "NodeSocketInterfaceVectorVelocity";
1768         case PROP_ACCELERATION:
1769           return "NodeSocketInterfaceVectorAcceleration";
1770         case PROP_EULER:
1771           return "NodeSocketInterfaceVectorEuler";
1772         case PROP_XYZ:
1773           return "NodeSocketInterfaceVectorXYZ";
1774         case PROP_NONE:
1775         default:
1776           return "NodeSocketInterfaceVector";
1777       }
1778     case SOCK_RGBA:
1779       return "NodeSocketInterfaceColor";
1780     case SOCK_STRING:
1781       return "NodeSocketInterfaceString";
1782     case SOCK_SHADER:
1783       return "NodeSocketInterfaceShader";
1784     case SOCK_OBJECT:
1785       return "NodeSocketInterfaceObject";
1786     case SOCK_IMAGE:
1787       return "NodeSocketInterfaceImage";
1788     case SOCK_GEOMETRY:
1789       return "NodeSocketInterfaceGeometry";
1790     case SOCK_COLLECTION:
1791       return "NodeSocketInterfaceCollection";
1792     case SOCK_TEXTURE:
1793       return "NodeSocketInterfaceTexture";
1794     case SOCK_MATERIAL:
1795       return "NodeSocketInterfaceMaterial";
1796   }
1797   return nullptr;
1798 }
1799
1800 bNodeSocket *nodeAddStaticSocket(bNodeTree *ntree,
1801                                  bNode *node,
1802                                  eNodeSocketInOut in_out,
1803                                  int type,
1804                                  int subtype,
1805                                  const char *identifier,
1806                                  const char *name)
1807 {
1808   const char *idname = nodeStaticSocketType(type, subtype);
1809
1810   if (!idname) {
1811     CLOG_ERROR(&LOG, "static node socket type %d undefined", type);
1812     return nullptr;
1813   }
1814
1815   bNodeSocket *sock = nodeAddSocket(ntree, node, in_out, idname, identifier, name);
1816   sock->type = type;
1817   return sock;
1818 }
1819
1820 bNodeSocket *nodeInsertStaticSocket(bNodeTree *ntree,
1821                                     bNode *node,
1822                                     eNodeSocketInOut in_out,
1823                                     int type,
1824                                     int subtype,
1825                                     bNodeSocket *next_sock,
1826                                     const char *identifier,
1827                                     const char *name)
1828 {
1829   const char *idname = nodeStaticSocketType(type, subtype);
1830
1831   if (!idname) {
1832     CLOG_ERROR(&LOG, "static node socket type %d undefined", type);
1833     return nullptr;
1834   }
1835
1836   bNodeSocket *sock = nodeInsertSocket(ntree, node, in_out, idname, next_sock, identifier, name);
1837   sock->type = type;
1838   return sock;
1839 }
1840
1841 static void node_socket_free(bNodeTree *UNUSED(ntree),
1842                              bNodeSocket *sock,
1843                              bNode *UNUSED(node),
1844                              const bool do_id_user)
1845 {
1846   if (sock->prop) {
1847     IDP_FreePropertyContent_ex(sock->prop, do_id_user);
1848     MEM_freeN(sock->prop);
1849   }
1850
1851   if (sock->default_value) {
1852     if (do_id_user) {
1853       socket_id_user_decrement(sock);
1854     }
1855     MEM_freeN(sock->default_value);
1856   }
1857 }
1858
1859 void nodeRemoveSocket(bNodeTree *ntree, bNode *node, bNodeSocket *sock)
1860 {
1861   LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
1862     if (link->fromsock == sock || link->tosock == sock) {
1863       nodeRemLink(ntree, link);
1864     }
1865   }
1866
1867   /* this is fast, this way we don't need an in_out argument */
1868   BLI_remlink(&node->inputs, sock);
1869   BLI_remlink(&node->outputs, sock);
1870
1871   node_socket_free(ntree, sock, node, true);
1872   MEM_freeN(sock);
1873
1874   node->update |= NODE_UPDATE;
1875 }
1876
1877 void nodeRemoveAllSockets(bNodeTree *ntree, bNode *node)
1878 {
1879   LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
1880     if (link->fromnode == node || link->tonode == node) {
1881       nodeRemLink(ntree, link);
1882     }
1883   }
1884
1885   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->inputs) {
1886     node_socket_free(ntree, sock, node, true);
1887     MEM_freeN(sock);
1888   }
1889   BLI_listbase_clear(&node->inputs);
1890
1891   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->outputs) {
1892     node_socket_free(ntree, sock, node, true);
1893     MEM_freeN(sock);
1894   }
1895   BLI_listbase_clear(&node->outputs);
1896
1897   node->update |= NODE_UPDATE;
1898 }
1899
1900 /* finds a node based on its name */
1901 bNode *nodeFindNodebyName(bNodeTree *ntree, const char *name)
1902 {
1903   return (bNode *)BLI_findstring(&ntree->nodes, name, offsetof(bNode, name));
1904 }
1905
1906 /* Finds a node based on given socket and returns true on success. */
1907 bool nodeFindNode(bNodeTree *ntree, bNodeSocket *sock, bNode **r_node, int *r_sockindex)
1908 {
1909   *r_node = nullptr;
1910
1911   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1912     ListBase *sockets = (sock->in_out == SOCK_IN) ? &node->inputs : &node->outputs;
1913     int index = 0;
1914     LISTBASE_FOREACH (bNodeSocket *, tsock, sockets) {
1915       if (sock == tsock) {
1916         if (r_node != nullptr) {
1917           *r_node = node;
1918         }
1919         if (r_sockindex != nullptr) {
1920           *r_sockindex = index;
1921         }
1922         return true;
1923       }
1924       index++;
1925     }
1926   }
1927   return false;
1928 }
1929
1930 /**
1931  * \note Recursive
1932  */
1933 bNode *nodeFindRootParent(bNode *node)
1934 {
1935   if (node->parent) {
1936     return nodeFindRootParent(node->parent);
1937   }
1938   return node->type == NODE_FRAME ? node : nullptr;
1939 }
1940
1941 /**
1942  * \returns true if \a child has \a parent as a parent/grandparent/...
1943  * \note Recursive
1944  */
1945 bool nodeIsChildOf(const bNode *parent, const bNode *child)
1946 {
1947   if (parent == child) {
1948     return true;
1949   }
1950   if (child->parent) {
1951     return nodeIsChildOf(parent, child->parent);
1952   }
1953   return false;
1954 }
1955
1956 /**
1957  * Iterate over a chain of nodes, starting with \a node_start, executing
1958  * \a callback for each node (which can return false to end iterator).
1959  *
1960  * \param reversed: for backwards iteration
1961  * \note Recursive
1962  */
1963 void nodeChainIter(const bNodeTree *ntree,
1964                    const bNode *node_start,
1965                    bool (*callback)(bNode *, bNode *, void *, const bool),
1966                    void *userdata,
1967                    const bool reversed)
1968 {
1969   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
1970     if ((link->flag & NODE_LINK_VALID) == 0) {
1971       /* Skip links marked as cyclic. */
1972       continue;
1973     }
1974     if (link->tonode && link->fromnode) {
1975       /* Is the link part of the chain meaning node_start == fromnode
1976        * (or tonode for reversed case)? */
1977       if ((reversed && (link->tonode == node_start)) ||
1978           (!reversed && link->fromnode == node_start)) {
1979         if (!callback(link->fromnode, link->tonode, userdata, reversed)) {
1980           return;
1981         }
1982         nodeChainIter(
1983             ntree, reversed ? link->fromnode : link->tonode, callback, userdata, reversed);
1984       }
1985     }
1986   }
1987 }
1988
1989 static void iter_backwards_ex(const bNodeTree *ntree,
1990                               const bNode *node_start,
1991                               bool (*callback)(bNode *, bNode *, void *),
1992                               void *userdata,
1993                               char recursion_mask)
1994 {
1995   LISTBASE_FOREACH (bNodeSocket *, sock, &node_start->inputs) {
1996     bNodeLink *link = sock->link;
1997     if (link == nullptr) {
1998       continue;
1999     }
2000     if ((link->flag & NODE_LINK_VALID) == 0) {
2001       /* Skip links marked as cyclic. */
2002       continue;
2003     }
2004     if (link->fromnode->iter_flag & recursion_mask) {
2005       continue;
2006     }
2007
2008     link->fromnode->iter_flag |= recursion_mask;
2009
2010     if (!callback(link->fromnode, link->tonode, userdata)) {
2011       return;
2012     }
2013     iter_backwards_ex(ntree, link->fromnode, callback, userdata, recursion_mask);
2014   }
2015 }
2016
2017 /**
2018  * Iterate over a chain of nodes, starting with \a node_start, executing
2019  * \a callback for each node (which can return false to end iterator).
2020  *
2021  * Faster than nodeChainIter. Iter only once per node.
2022  * Can be called recursively (using another nodeChainIterBackwards) by
2023  * setting the recursion_lvl accordingly.
2024  *
2025  * \note Needs updated socket links (ntreeUpdateTree).
2026  * \note Recursive
2027  */
2028 void nodeChainIterBackwards(const bNodeTree *ntree,
2029                             const bNode *node_start,
2030                             bool (*callback)(bNode *, bNode *, void *),
2031                             void *userdata,
2032                             int recursion_lvl)
2033 {
2034   if (!node_start) {
2035     return;
2036   }
2037
2038   /* Limited by iter_flag type. */
2039   BLI_assert(recursion_lvl < 8);
2040   char recursion_mask = (1 << recursion_lvl);
2041
2042   /* Reset flag. */
2043   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2044     node->iter_flag &= ~recursion_mask;
2045   }
2046
2047   iter_backwards_ex(ntree, node_start, callback, userdata, recursion_mask);
2048 }
2049
2050 /**
2051  * Iterate over all parents of \a node, executing \a callback for each parent
2052  * (which can return false to end iterator)
2053  *
2054  * \note Recursive
2055  */
2056 void nodeParentsIter(bNode *node, bool (*callback)(bNode *, void *), void *userdata)
2057 {
2058   if (node->parent) {
2059     if (!callback(node->parent, userdata)) {
2060       return;
2061     }
2062     nodeParentsIter(node->parent, callback, userdata);
2063   }
2064 }
2065
2066 /* ************** Add stuff ********** */
2067
2068 /* Find the first available, non-duplicate name for a given node */
2069 void nodeUniqueName(bNodeTree *ntree, bNode *node)
2070 {
2071   BLI_uniquename(
2072       &ntree->nodes, node, DATA_("Node"), '.', offsetof(bNode, name), sizeof(node->name));
2073 }
2074
2075 bNode *nodeAddNode(const struct bContext *C, bNodeTree *ntree, const char *idname)
2076 {
2077   bNode *node = (bNode *)MEM_callocN(sizeof(bNode), "new node");
2078   BLI_addtail(&ntree->nodes, node);
2079
2080   BLI_strncpy(node->idname, idname, sizeof(node->idname));
2081   node_set_typeinfo(C, ntree, node, nodeTypeFind(idname));
2082
2083   ntree->update |= NTREE_UPDATE_NODES;
2084
2085   return node;
2086 }
2087
2088 bNode *nodeAddStaticNode(const struct bContext *C, bNodeTree *ntree, int type)
2089 {
2090   const char *idname = nullptr;
2091
2092   NODE_TYPES_BEGIN (ntype) {
2093     /* do an extra poll here, because some int types are used
2094      * for multiple node types, this helps find the desired type
2095      */
2096     const char *disabled_hint;
2097     if (ntype->type == type && (!ntype->poll || ntype->poll(ntype, ntree, &disabled_hint))) {
2098       idname = ntype->idname;
2099       break;
2100     }
2101   }
2102   NODE_TYPES_END;
2103   if (!idname) {
2104     CLOG_ERROR(&LOG, "static node type %d undefined", type);
2105     return nullptr;
2106   }
2107   return nodeAddNode(C, ntree, idname);
2108 }
2109
2110 static void node_socket_copy(bNodeSocket *sock_dst, const bNodeSocket *sock_src, const int flag)
2111 {
2112   if (sock_src->prop) {
2113     sock_dst->prop = IDP_CopyProperty_ex(sock_src->prop, flag);
2114   }
2115
2116   if (sock_src->default_value) {
2117     sock_dst->default_value = MEM_dupallocN(sock_src->default_value);
2118
2119     if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
2120       socket_id_user_increment(sock_dst);
2121     }
2122   }
2123
2124   sock_dst->stack_index = 0;
2125   /* XXX some compositor node (e.g. image, render layers) still store
2126    * some persistent buffer data here, need to clear this to avoid dangling pointers.
2127    */
2128   sock_dst->cache = nullptr;
2129 }
2130
2131 /* keep socket listorder identical, for copying links */
2132 /* ntree is the target tree */
2133 /* unique_name needs to be true. It's only disabled for speed when doing GPUnodetrees. */
2134 bNode *BKE_node_copy_ex(bNodeTree *ntree,
2135                         const bNode *node_src,
2136                         const int flag,
2137                         const bool unique_name)
2138 {
2139   bNode *node_dst = (bNode *)MEM_callocN(sizeof(bNode), "dupli node");
2140   bNodeSocket *sock_dst, *sock_src;
2141   bNodeLink *link_dst, *link_src;
2142
2143   *node_dst = *node_src;
2144   /* can be called for nodes outside a node tree (e.g. clipboard) */
2145   if (ntree) {
2146     if (unique_name) {
2147       nodeUniqueName(ntree, node_dst);
2148     }
2149
2150     BLI_addtail(&ntree->nodes, node_dst);
2151   }
2152
2153   BLI_duplicatelist(&node_dst->inputs, &node_src->inputs);
2154   for (sock_dst = (bNodeSocket *)node_dst->inputs.first,
2155       sock_src = (bNodeSocket *)node_src->inputs.first;
2156        sock_dst != nullptr;
2157        sock_dst = (bNodeSocket *)sock_dst->next, sock_src = (bNodeSocket *)sock_src->next) {
2158     node_socket_copy(sock_dst, sock_src, flag);
2159   }
2160
2161   BLI_duplicatelist(&node_dst->outputs, &node_src->outputs);
2162   for (sock_dst = (bNodeSocket *)node_dst->outputs.first,
2163       sock_src = (bNodeSocket *)node_src->outputs.first;
2164        sock_dst != nullptr;
2165        sock_dst = (bNodeSocket *)sock_dst->next, sock_src = (bNodeSocket *)sock_src->next) {
2166     node_socket_copy(sock_dst, sock_src, flag);
2167   }
2168
2169   if (node_src->prop) {
2170     node_dst->prop = IDP_CopyProperty_ex(node_src->prop, flag);
2171   }
2172
2173   BLI_duplicatelist(&node_dst->internal_links, &node_src->internal_links);
2174   for (link_dst = (bNodeLink *)node_dst->internal_links.first,
2175       link_src = (bNodeLink *)node_src->internal_links.first;
2176        link_dst != nullptr;
2177        link_dst = (bNodeLink *)link_dst->next, link_src = (bNodeLink *)link_src->next) {
2178     /* This is a bit annoying to do index lookups in a list, but is likely to be faster than
2179      * trying to create a hash-map. At least for usual nodes, which only have so much sockets
2180      * and internal links. */
2181     const int from_sock_index = BLI_findindex(&node_src->inputs, link_src->fromsock);
2182     const int to_sock_index = BLI_findindex(&node_src->outputs, link_src->tosock);
2183     BLI_assert(from_sock_index != -1);
2184     BLI_assert(to_sock_index != -1);
2185     link_dst->fromnode = node_dst;
2186     link_dst->tonode = node_dst;
2187     link_dst->fromsock = (bNodeSocket *)BLI_findlink(&node_dst->inputs, from_sock_index);
2188     link_dst->tosock = (bNodeSocket *)BLI_findlink(&node_dst->outputs, to_sock_index);
2189   }
2190
2191   if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
2192     id_us_plus(node_dst->id);
2193   }
2194
2195   if (node_src->typeinfo->copyfunc) {
2196     node_src->typeinfo->copyfunc(ntree, node_dst, node_src);
2197   }
2198
2199   node_dst->new_node = nullptr;
2200
2201   /* Only call copy function when a copy is made for the main database, not
2202    * for cases like the dependency graph and localization. */
2203   if (node_dst->typeinfo->copyfunc_api && !(flag & LIB_ID_CREATE_NO_MAIN)) {
2204     PointerRNA ptr;
2205     RNA_pointer_create((ID *)ntree, &RNA_Node, node_dst, &ptr);
2206
2207     node_dst->typeinfo->copyfunc_api(&ptr, node_src);
2208   }
2209
2210   if (ntree) {
2211     ntree->update |= NTREE_UPDATE_NODES;
2212   }
2213
2214   return node_dst;
2215 }
2216
2217 static void node_set_new_pointers(bNode *node_src, bNode *new_node)
2218 {
2219   /* Store mapping to the node itself. */
2220   node_src->new_node = new_node;
2221   /* Store mapping to inputs. */
2222   bNodeSocket *new_input_sock = (bNodeSocket *)new_node->inputs.first;
2223   bNodeSocket *input_sock_src = (bNodeSocket *)node_src->inputs.first;
2224   while (new_input_sock != nullptr) {
2225     input_sock_src->new_sock = new_input_sock;
2226     new_input_sock = new_input_sock->next;
2227     input_sock_src = input_sock_src->next;
2228   }
2229   /* Store mapping to outputs. */
2230   bNodeSocket *new_output_sock = (bNodeSocket *)new_node->outputs.first;
2231   bNodeSocket *output_sock_src = (bNodeSocket *)node_src->outputs.first;
2232   while (new_output_sock != nullptr) {
2233     output_sock_src->new_sock = new_output_sock;
2234     new_output_sock = new_output_sock->next;
2235     output_sock_src = output_sock_src->next;
2236   }
2237 }
2238
2239 bNode *BKE_node_copy_store_new_pointers(bNodeTree *ntree, bNode *node_src, const int flag)
2240 {
2241   bNode *new_node = BKE_node_copy_ex(ntree, node_src, flag, true);
2242   node_set_new_pointers(node_src, new_node);
2243   return new_node;
2244 }
2245
2246 bNodeTree *ntreeCopyTree_ex_new_pointers(const bNodeTree *ntree,
2247                                          Main *bmain,
2248                                          const bool do_id_user)
2249 {
2250   bNodeTree *new_ntree = ntreeCopyTree_ex(ntree, bmain, do_id_user);
2251   bNode *new_node = (bNode *)new_ntree->nodes.first;
2252   bNode *node_src = (bNode *)ntree->nodes.first;
2253   while (new_node != nullptr) {
2254     node_set_new_pointers(node_src, new_node);
2255     new_node = new_node->next;
2256     node_src = node_src->next;
2257   }
2258   return new_ntree;
2259 }
2260
2261 static int node_count_links(const bNodeTree *ntree, const bNodeSocket *socket)
2262 {
2263   int count = 0;
2264   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
2265     if (ELEM(socket, link->fromsock, link->tosock)) {
2266       count++;
2267     }
2268   }
2269   return count;
2270 }
2271
2272 /* also used via rna api, so we check for proper input output direction */
2273 bNodeLink *nodeAddLink(
2274     bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, bNode *tonode, bNodeSocket *tosock)
2275 {
2276   bNodeLink *link = nullptr;
2277
2278   /* test valid input */
2279   BLI_assert(fromnode);
2280   BLI_assert(tonode);
2281
2282   if (fromsock->in_out == SOCK_OUT && tosock->in_out == SOCK_IN) {
2283     link = (bNodeLink *)MEM_callocN(sizeof(bNodeLink), "link");
2284     if (ntree) {
2285       BLI_addtail(&ntree->links, link);
2286     }
2287     link->fromnode = fromnode;
2288     link->fromsock = fromsock;
2289     link->tonode = tonode;
2290     link->tosock = tosock;
2291   }
2292   else if (fromsock->in_out == SOCK_IN && tosock->in_out == SOCK_OUT) {
2293     /* OK but flip */
2294     link = (bNodeLink *)MEM_callocN(sizeof(bNodeLink), "link");
2295     if (ntree) {
2296       BLI_addtail(&ntree->links, link);
2297     }
2298     link->fromnode = tonode;
2299     link->fromsock = tosock;
2300     link->tonode = fromnode;
2301     link->tosock = fromsock;
2302   }
2303
2304   if (ntree) {
2305     ntree->update |= NTREE_UPDATE_LINKS;
2306   }
2307
2308   if (link->tosock->flag & SOCK_MULTI_INPUT) {
2309     link->multi_input_socket_index = node_count_links(ntree, link->tosock) - 1;
2310   }
2311
2312   return link;
2313 }
2314
2315 void nodeRemLink(bNodeTree *ntree, bNodeLink *link)
2316 {
2317   /* can be called for links outside a node tree (e.g. clipboard) */
2318   if (ntree) {
2319     BLI_remlink(&ntree->links, link);
2320   }
2321
2322   if (link->tosock) {
2323     link->tosock->link = nullptr;
2324   }
2325   MEM_freeN(link);
2326
2327   if (ntree) {
2328     ntree->update |= NTREE_UPDATE_LINKS;
2329   }
2330 }
2331
2332 /* Check if all output links are muted or not. */
2333 static bool nodeMuteFromSocketLinks(const bNodeTree *ntree, const bNodeSocket *sock)
2334 {
2335   int tot = 0;
2336   int muted = 0;
2337   LISTBASE_FOREACH (const bNodeLink *, link, &ntree->links) {
2338     if (link->fromsock == sock) {
2339       tot++;
2340       if (link->flag & NODE_LINK_MUTED) {
2341         muted++;
2342       }
2343     }
2344   }
2345   return tot == muted;
2346 }
2347
2348 static void nodeMuteLink(bNodeLink *link)
2349 {
2350   link->flag |= NODE_LINK_MUTED;
2351   link->flag |= NODE_LINK_TEST;
2352   if (!(link->tosock->flag & SOCK_MULTI_INPUT)) {
2353     link->tosock->flag &= ~SOCK_IN_USE;
2354   }
2355 }
2356
2357 static void nodeUnMuteLink(bNodeLink *link)
2358 {
2359   link->flag &= ~NODE_LINK_MUTED;
2360   link->flag |= NODE_LINK_TEST;
2361   link->tosock->flag |= SOCK_IN_USE;
2362 }
2363
2364 /* Upstream muting. Always happens when unmuting but checks when muting. O(n^2) algorithm.*/
2365 static void nodeMuteRerouteInputLinks(bNodeTree *ntree, bNode *node, const bool mute)
2366 {
2367   if (node->type != NODE_REROUTE) {
2368     return;
2369   }
2370   if (!mute || nodeMuteFromSocketLinks(ntree, (bNodeSocket *)node->outputs.first)) {
2371     bNodeSocket *sock = (bNodeSocket *)node->inputs.first;
2372     LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
2373       if (!(link->flag & NODE_LINK_VALID) || (link->tosock != sock)) {
2374         continue;
2375       }
2376       if (mute) {
2377         nodeMuteLink(link);
2378       }
2379       else {
2380         nodeUnMuteLink(link);
2381       }
2382       nodeMuteRerouteInputLinks(ntree, link->fromnode, mute);
2383     }
2384   }
2385 }
2386
2387 /* Downstream muting propagates when reaching reroute nodes. O(n^2) algorithm.*/
2388 static void nodeMuteRerouteOutputLinks(bNodeTree *ntree, bNode *node, const bool mute)
2389 {
2390   if (node->type != NODE_REROUTE) {
2391     return;
2392   }
2393   bNodeSocket *sock;
2394   sock = (bNodeSocket *)node->outputs.first;
2395   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
2396     if (!(link->flag & NODE_LINK_VALID) || (link->fromsock != sock)) {
2397       continue;
2398     }
2399     if (mute) {
2400       nodeMuteLink(link);
2401     }
2402     else {
2403       nodeUnMuteLink(link);
2404     }
2405     nodeMuteRerouteOutputLinks(ntree, link->tonode, mute);
2406   }
2407 }
2408
2409 void nodeMuteLinkToggle(bNodeTree *ntree, bNodeLink *link)
2410 {
2411   if (link->tosock) {
2412     bool mute = !(link->flag & NODE_LINK_MUTED);
2413     if (mute) {
2414       nodeMuteLink(link);
2415     }
2416     else {
2417       nodeUnMuteLink(link);
2418     }
2419     if (link->tonode->type == NODE_REROUTE) {
2420       nodeMuteRerouteOutputLinks(ntree, link->tonode, mute);
2421     }
2422     if (link->fromnode->type == NODE_REROUTE) {
2423       nodeMuteRerouteInputLinks(ntree, link->fromnode, mute);
2424     }
2425   }
2426
2427   if (ntree) {
2428     ntree->update |= NTREE_UPDATE_LINKS;
2429   }
2430 }
2431
2432 void nodeRemSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
2433 {
2434   LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
2435     if (link->fromsock == sock || link->tosock == sock) {
2436       nodeRemLink(ntree, link);
2437     }
2438   }
2439
2440   ntree->update |= NTREE_UPDATE_LINKS;
2441 }
2442
2443 bool nodeLinkIsHidden(const bNodeLink *link)
2444 {
2445   return nodeSocketIsHidden(link->fromsock) || nodeSocketIsHidden(link->tosock);
2446 }
2447
2448 void nodeInternalRelink(bNodeTree *ntree, bNode *node)
2449 {
2450   /* store link pointers in output sockets, for efficient lookup */
2451   LISTBASE_FOREACH (bNodeLink *, link, &node->internal_links) {
2452     link->tosock->link = link;
2453   }
2454
2455   /* redirect downstream links */
2456   LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
2457     /* do we have internal link? */
2458     if (link->fromnode == node) {
2459       if (link->fromsock->link) {
2460         /* get the upstream input link */
2461         bNodeLink *fromlink = link->fromsock->link->fromsock->link;
2462         /* skip the node */
2463         if (fromlink) {
2464           link->fromnode = fromlink->fromnode;
2465           link->fromsock = fromlink->fromsock;
2466
2467           /* if the up- or downstream link is invalid,
2468            * the replacement link will be invalid too.
2469            */
2470           if (!(fromlink->flag & NODE_LINK_VALID)) {
2471             link->flag &= ~NODE_LINK_VALID;
2472           }
2473
2474           if (fromlink->flag & NODE_LINK_MUTED) {
2475             link->flag |= NODE_LINK_MUTED;
2476           }
2477
2478           ntree->update |= NTREE_UPDATE_LINKS;
2479         }
2480         else {
2481           nodeRemLink(ntree, link);
2482         }
2483       }
2484       else {
2485         nodeRemLink(ntree, link);
2486       }
2487     }
2488   }
2489
2490   /* remove remaining upstream links */
2491   LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
2492     if (link->tonode == node) {
2493       nodeRemLink(ntree, link);
2494     }
2495   }
2496 }
2497
2498 void nodeToView(const bNode *node, float x, float y, float *rx, float *ry)
2499 {
2500   if (node->parent) {
2501     nodeToView(node->parent, x + node->locx, y + node->locy, rx, ry);
2502   }
2503   else {
2504     *rx = x + node->locx;
2505     *ry = y + node->locy;
2506   }
2507 }
2508
2509 void nodeFromView(const bNode *node, float x, float y, float *rx, float *ry)
2510 {
2511   if (node->parent) {
2512     nodeFromView(node->parent, x, y, rx, ry);
2513     *rx -= node->locx;
2514     *ry -= node->locy;
2515   }
2516   else {
2517     *rx = x - node->locx;
2518     *ry = y - node->locy;
2519   }
2520 }
2521
2522 bool nodeAttachNodeCheck(const bNode *node, const bNode *parent)
2523 {
2524   for (const bNode *parent_iter = node; parent_iter; parent_iter = parent_iter->parent) {
2525     if (parent_iter == parent) {
2526       return true;
2527     }
2528   }
2529
2530   return false;
2531 }
2532
2533 void nodeAttachNode(bNode *node, bNode *parent)
2534 {
2535   BLI_assert(parent->type == NODE_FRAME);
2536   BLI_assert(nodeAttachNodeCheck(parent, node) == false);
2537
2538   float locx, locy;
2539   nodeToView(node, 0.0f, 0.0f, &locx, &locy);
2540
2541   node->parent = parent;
2542   /* transform to parent space */
2543   nodeFromView(parent, locx, locy, &node->locx, &node->locy);
2544 }
2545
2546 void nodeDetachNode(struct bNode *node)
2547 {
2548   if (node->parent) {
2549     BLI_assert(node->parent->type == NODE_FRAME);
2550
2551     /* transform to view space */
2552     float locx, locy;
2553     nodeToView(node, 0.0f, 0.0f, &locx, &locy);
2554     node->locx = locx;
2555     node->locy = locy;
2556     node->parent = nullptr;
2557   }
2558 }
2559
2560 void nodePositionRelative(bNode *from_node,
2561                           bNode *to_node,
2562                           bNodeSocket *from_sock,
2563                           bNodeSocket *to_sock)
2564 {
2565   float offset_x;
2566   int tot_sock_idx;
2567
2568   /* Socket to plug into. */
2569   if (SOCK_IN == to_sock->in_out) {
2570     offset_x = -(from_node->typeinfo->width + 50);
2571     tot_sock_idx = BLI_listbase_count(&to_node->outputs);
2572     tot_sock_idx += BLI_findindex(&to_node->inputs, to_sock);
2573   }
2574   else {
2575     offset_x = to_node->typeinfo->width + 50;
2576     tot_sock_idx = BLI_findindex(&to_node->outputs, to_sock);
2577   }
2578
2579   BLI_assert(tot_sock_idx != -1);
2580
2581   float offset_y = U.widget_unit * tot_sock_idx;
2582
2583   /* Output socket. */
2584   if (from_sock) {
2585     if (SOCK_IN == from_sock->in_out) {
2586       tot_sock_idx = BLI_listbase_count(&from_node->outputs);
2587       tot_sock_idx += BLI_findindex(&from_node->inputs, from_sock);
2588     }
2589     else {
2590       tot_sock_idx = BLI_findindex(&from_node->outputs, from_sock);
2591     }
2592   }
2593
2594   BLI_assert(tot_sock_idx != -1);
2595
2596   offset_y -= U.widget_unit * tot_sock_idx;
2597
2598   from_node->locx = to_node->locx + offset_x;
2599   from_node->locy = to_node->locy - offset_y;
2600 }
2601
2602 void nodePositionPropagate(bNode *node)
2603 {
2604   LISTBASE_FOREACH (bNodeSocket *, nsock, &node->inputs) {
2605     if (nsock->link != nullptr) {
2606       bNodeLink *link = nsock->link;
2607       nodePositionRelative(link->fromnode, link->tonode, link->fromsock, link->tosock);
2608       nodePositionPropagate(link->fromnode);
2609     }
2610   }
2611 }
2612
2613 bNodeTree *ntreeAddTree(Main *bmain, const char *name, const char *idname)
2614 {
2615   /* trees are created as local trees for compositor, material or texture nodes,
2616    * node groups and other tree types are created as library data.
2617    */
2618   const bool is_embedded = (bmain == nullptr);
2619   int flag = 0;
2620   if (is_embedded) {
2621     flag |= LIB_ID_CREATE_NO_MAIN;
2622   }
2623   bNodeTree *ntree = (bNodeTree *)BKE_libblock_alloc(bmain, ID_NT, name, flag);
2624   if (is_embedded) {
2625     ntree->id.flag |= LIB_EMBEDDED_DATA;
2626   }
2627
2628   /* Types are fully initialized at this point,
2629    * if an undefined node is added later this will be reset.
2630    */
2631   ntree->init |= NTREE_TYPE_INIT;
2632
2633   BLI_strncpy(ntree->idname, idname, sizeof(ntree->idname));
2634   ntree_set_typeinfo(ntree, ntreeTypeFind(idname));
2635
2636   return ntree;
2637 }
2638
2639 bNodeTree *ntreeCopyTree_ex(const bNodeTree *ntree, Main *bmain, const bool do_id_user)
2640 {
2641   const int flag = do_id_user ? 0 : LIB_ID_CREATE_NO_USER_REFCOUNT | LIB_ID_CREATE_NO_MAIN;
2642
2643   bNodeTree *ntree_copy = (bNodeTree *)BKE_id_copy_ex(bmain, (ID *)ntree, nullptr, flag);
2644   return ntree_copy;
2645 }
2646 bNodeTree *ntreeCopyTree(Main *bmain, const bNodeTree *ntree)
2647 {
2648   return ntreeCopyTree_ex(ntree, bmain, true);
2649 }
2650
2651 /* *************** Node Preview *********** */
2652
2653 /* XXX this should be removed eventually ...
2654  * Currently BKE functions are modeled closely on previous code,
2655  * using BKE_node_preview_init_tree to set up previews for a whole node tree in advance.
2656  * This should be left more to the individual node tree implementations.
2657  */
2658 bool BKE_node_preview_used(const bNode *node)
2659 {
2660   /* XXX check for closed nodes? */
2661   return (node->typeinfo->flag & NODE_PREVIEW) != 0;
2662 }
2663
2664 bNodePreview *BKE_node_preview_verify(
2665     bNodeInstanceHash *previews, bNodeInstanceKey key, int xsize, int ysize, bool create)
2666 {
2667   bNodePreview *preview = (bNodePreview *)BKE_node_instance_hash_lookup(previews, key);
2668   if (!preview) {
2669     if (create) {
2670       preview = (bNodePreview *)MEM_callocN(sizeof(bNodePreview), "node preview");
2671       BKE_node_instance_hash_insert(previews, key, preview);
2672     }
2673     else {
2674       return nullptr;
2675     }
2676   }
2677
2678   /* node previews can get added with variable size this way */
2679   if (xsize == 0 || ysize == 0) {
2680     return preview;
2681   }
2682
2683   /* sanity checks & initialize */
2684   if (preview->rect) {
2685     if (preview->xsize != xsize || preview->ysize != ysize) {
2686       MEM_freeN(preview->rect);
2687       preview->rect = nullptr;
2688     }
2689   }
2690
2691   if (preview->rect == nullptr) {
2692     preview->rect = (unsigned char *)MEM_callocN(4 * xsize + xsize * ysize * sizeof(char[4]),
2693                                                  "node preview rect");
2694     preview->xsize = xsize;
2695     preview->ysize = ysize;
2696   }
2697   /* no clear, makes nicer previews */
2698
2699   return preview;
2700 }
2701
2702 bNodePreview *BKE_node_preview_copy(bNodePreview *preview)
2703 {
2704   bNodePreview *new_preview = (bNodePreview *)MEM_dupallocN(preview);
2705   if (preview->rect) {
2706     new_preview->rect = (unsigned char *)MEM_dupallocN(preview->rect);
2707   }
2708   return new_preview;
2709 }
2710
2711 void BKE_node_preview_free(bNodePreview *preview)
2712 {
2713   if (preview->rect) {
2714     MEM_freeN(preview->rect);
2715   }
2716   MEM_freeN(preview);
2717 }
2718
2719 static void node_preview_init_tree_recursive(bNodeInstanceHash *previews,
2720                                              bNodeTree *ntree,
2721                                              bNodeInstanceKey parent_key,
2722                                              int xsize,
2723                                              int ysize,
2724                                              bool create_previews)
2725 {
2726   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2727     bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node);
2728
2729     if (BKE_node_preview_used(node)) {
2730       node->preview_xsize = xsize;
2731       node->preview_ysize = ysize;
2732
2733       BKE_node_preview_verify(previews, key, xsize, ysize, create_previews);
2734     }
2735
2736     if (node->type == NODE_GROUP && node->id) {
2737       node_preview_init_tree_recursive(
2738           previews, (bNodeTree *)node->id, key, xsize, ysize, create_previews);
2739     }
2740   }
2741 }
2742
2743 void BKE_node_preview_init_tree(bNodeTree *ntree, int xsize, int ysize, bool create_previews)
2744 {
2745   if (!ntree) {
2746     return;
2747   }
2748
2749   if (!ntree->previews) {
2750     ntree->previews = BKE_node_instance_hash_new("node previews");
2751   }
2752
2753   node_preview_init_tree_recursive(
2754       ntree->previews, ntree, NODE_INSTANCE_KEY_BASE, xsize, ysize, create_previews);
2755 }
2756
2757 static void node_preview_tag_used_recursive(bNodeInstanceHash *previews,
2758                                             bNodeTree *ntree,
2759                                             bNodeInstanceKey parent_key)
2760 {
2761   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2762     bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node);
2763
2764     if (BKE_node_preview_used(node)) {
2765       BKE_node_instance_hash_tag_key(previews, key);
2766     }
2767
2768     if (node->type == NODE_GROUP && node->id) {
2769       node_preview_tag_used_recursive(previews, (bNodeTree *)node->id, key);
2770     }
2771   }
2772 }
2773
2774 void BKE_node_preview_remove_unused(bNodeTree *ntree)
2775 {
2776   if (!ntree || !ntree->previews) {
2777     return;
2778   }
2779
2780   /* use the instance hash functions for tagging and removing unused previews */
2781   BKE_node_instance_hash_clear_tags(ntree->previews);
2782   node_preview_tag_used_recursive(ntree->previews, ntree, NODE_INSTANCE_KEY_BASE);
2783
2784   BKE_node_instance_hash_remove_untagged(ntree->previews,
2785                                          (bNodeInstanceValueFP)BKE_node_preview_free);
2786 }
2787
2788 void BKE_node_preview_free_tree(bNodeTree *ntree)
2789 {
2790   if (!ntree) {
2791     return;
2792   }
2793
2794   if (ntree->previews) {
2795     BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
2796     ntree->previews = nullptr;
2797   }
2798 }
2799
2800 void BKE_node_preview_clear(bNodePreview *preview)
2801 {
2802   if (preview && preview->rect) {
2803     memset(preview->rect, 0, MEM_allocN_len(preview->rect));
2804   }
2805 }
2806
2807 void BKE_node_preview_clear_tree(bNodeTree *ntree)
2808 {
2809   if (!ntree || !ntree->previews) {
2810     return;
2811   }
2812
2813   bNodeInstanceHashIterator iter;
2814   NODE_INSTANCE_HASH_ITER (iter, ntree->previews) {
2815     bNodePreview *preview = (bNodePreview *)BKE_node_instance_hash_iterator_get_value(&iter);
2816     BKE_node_preview_clear(preview);
2817   }
2818 }
2819
2820 static void node_preview_sync(bNodePreview *to, bNodePreview *from)
2821 {
2822   /* sizes should have been initialized by BKE_node_preview_init_tree */
2823   BLI_assert(to->xsize == from->xsize && to->ysize == from->ysize);
2824
2825   /* copy over contents of previews */
2826   if (to->rect && from->rect) {
2827     int xsize = to->xsize;
2828     int ysize = to->ysize;
2829     memcpy(to->rect, from->rect, xsize * ysize * sizeof(char[4]));
2830   }
2831 }
2832
2833 void BKE_node_preview_sync_tree(bNodeTree *to_ntree, bNodeTree *from_ntree)
2834 {
2835   bNodeInstanceHash *from_previews = from_ntree->previews;
2836   bNodeInstanceHash *to_previews = to_ntree->previews;
2837
2838   if (!from_previews || !to_previews) {
2839     return;
2840   }
2841
2842   bNodeInstanceHashIterator iter;
2843   NODE_INSTANCE_HASH_ITER (iter, from_previews) {
2844     bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
2845     bNodePreview *from = (bNodePreview *)BKE_node_instance_hash_iterator_get_value(&iter);
2846     bNodePreview *to = (bNodePreview *)BKE_node_instance_hash_lookup(to_previews, key);
2847
2848     if (from && to) {
2849       node_preview_sync(to, from);
2850     }
2851   }
2852 }
2853
2854 void BKE_node_preview_merge_tree(bNodeTree *to_ntree, bNodeTree *from_ntree, bool remove_old)
2855 {
2856   if (remove_old || !to_ntree->previews) {
2857     /* free old previews */
2858     if (to_ntree->previews) {
2859       BKE_node_instance_hash_free(to_ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
2860     }
2861
2862     /* transfer previews */
2863     to_ntree->previews = from_ntree->previews;
2864     from_ntree->previews = nullptr;
2865
2866     /* clean up, in case any to_ntree nodes have been removed */
2867     BKE_node_preview_remove_unused(to_ntree);
2868   }
2869   else {
2870     if (from_ntree->previews) {
2871       bNodeInstanceHashIterator iter;
2872       NODE_INSTANCE_HASH_ITER (iter, from_ntree->previews) {
2873         bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
2874         bNodePreview *preview = (bNodePreview *)BKE_node_instance_hash_iterator_get_value(&iter);
2875
2876         /* replace existing previews */
2877         BKE_node_instance_hash_remove(
2878             to_ntree->previews, key, (bNodeInstanceValueFP)BKE_node_preview_free);
2879         BKE_node_instance_hash_insert(to_ntree->previews, key, preview);
2880       }
2881
2882       /* Note: null free function here,
2883        * because pointers have already been moved over to to_ntree->previews! */
2884       BKE_node_instance_hash_free(from_ntree->previews, nullptr);
2885       from_ntree->previews = nullptr;
2886     }
2887   }
2888 }
2889
2890 /* hack warning! this function is only used for shader previews, and
2891  * since it gets called multiple times per pixel for Ztransp we only
2892  * add the color once. Preview gets cleared before it starts render though */
2893 void BKE_node_preview_set_pixel(
2894     bNodePreview *preview, const float col[4], int x, int y, bool do_manage)
2895 {
2896   if (preview) {
2897     if (x >= 0 && y >= 0) {
2898       if (x < preview->xsize && y < preview->ysize) {
2899         unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x);
2900
2901         if (do_manage) {
2902           linearrgb_to_srgb_uchar4(tar, col);
2903         }
2904         else {
2905           rgba_float_to_uchar(tar, col);
2906         }
2907       }
2908       // else printf("prv out bound x y %d %d\n", x, y);
2909     }
2910     // else printf("prv out bound x y %d %d\n", x, y);
2911   }
2912 }
2913
2914 /* ************** Free stuff ********** */
2915
2916 /* goes over entire tree */
2917 void nodeUnlinkNode(bNodeTree *ntree, bNode *node)
2918 {
2919   LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
2920     ListBase *lb;
2921     if (link->fromnode == node) {
2922       lb = &node->outputs;
2923       if (link->tonode) {
2924         link->tonode->update |= NODE_UPDATE;
2925       }
2926     }
2927     else if (link->tonode == node) {
2928       lb = &node->inputs;
2929     }
2930     else {
2931       lb = nullptr;
2932     }
2933
2934     if (lb) {
2935       LISTBASE_FOREACH (bNodeSocket *, sock, lb) {
2936         if (link->fromsock == sock || link->tosock == sock) {
2937           nodeRemLink(ntree, link);
2938           break;
2939         }
2940       }
2941     }
2942   }
2943 }
2944
2945 static void node_unlink_attached(bNodeTree *ntree, bNode *parent)
2946 {
2947   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2948     if (node->parent == parent) {
2949       nodeDetachNode(node);
2950     }
2951   }
2952 }
2953
2954 /* Free the node itself. ID user refcounting is up the caller,
2955  * that does not happen here. */
2956 static void node_free_node(bNodeTree *ntree, bNode *node)
2957 {
2958   /* since it is called while free database, node->id is undefined */
2959
2960   /* can be called for nodes outside a node tree (e.g. clipboard) */
2961   if (ntree) {
2962     /* remove all references to this node */
2963     nodeUnlinkNode(ntree, node);
2964     node_unlink_attached(ntree, node);
2965
2966     BLI_remlink(&ntree->nodes, node);
2967
2968     if (ntree->typeinfo->free_node_cache) {
2969       ntree->typeinfo->free_node_cache(ntree, node);
2970     }
2971
2972     /* texture node has bad habit of keeping exec data around */
2973     if (ntree->type == NTREE_TEXTURE && ntree->execdata) {
2974       ntreeTexEndExecTree(ntree->execdata);
2975       ntree->execdata = nullptr;
2976     }
2977   }
2978
2979   if (node->typeinfo->freefunc) {
2980     node->typeinfo->freefunc(node);
2981   }
2982
2983   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->inputs) {
2984     /* Remember, no ID user refcount management here! */
2985     node_socket_free(ntree, sock, node, false);
2986     MEM_freeN(sock);
2987   }
2988   LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->outputs) {
2989     /* Remember, no ID user refcount management here! */
2990     node_socket_free(ntree, sock, node, false);
2991     MEM_freeN(sock);
2992   }
2993
2994   BLI_freelistN(&node->internal_links);
2995
2996   if (node->prop) {
2997     /* Remember, no ID user refcount management here! */
2998     IDP_FreePropertyContent_ex(node->prop, false);
2999     MEM_freeN(node->prop);
3000   }
3001
3002   MEM_freeN(node);
3003
3004   if (ntree) {
3005     ntree->update |= NTREE_UPDATE_NODES;
3006   }
3007 }
3008
3009 void ntreeFreeLocalNode(bNodeTree *ntree, bNode *node)
3010 {
3011   /* For removing nodes while editing localized node trees. */
3012   BLI_assert((ntree->id.tag & LIB_TAG_LOCALIZED) != 0);
3013   node_free_node(ntree, node);
3014 }
3015
3016 void nodeRemoveNode(Main *bmain, bNodeTree *ntree, bNode *node, bool do_id_user)
3017 {
3018   /* This function is not for localized node trees, we do not want
3019    * do to ID user refcounting and removal of animdation data then. */
3020   BLI_assert((ntree->id.tag & LIB_TAG_LOCALIZED) == 0);
3021
3022   if (do_id_user) {
3023     /* Free callback for NodeCustomGroup. */
3024     if (node->typeinfo->freefunc_api) {
3025       PointerRNA ptr;
3026       RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
3027
3028       node->typeinfo->freefunc_api(&ptr);
3029     }
3030
3031     /* Do user counting. */
3032     if (node->id) {
3033       id_us_min(node->id);
3034     }
3035
3036     LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
3037       socket_id_user_decrement(sock);
3038     }
3039     LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
3040       socket_id_user_decrement(sock);
3041     }
3042   }
3043
3044   /* Remove animation data. */
3045   char propname_esc[MAX_IDPROP_NAME * 2];
3046   char prefix[MAX_IDPROP_NAME * 2];
3047
3048   BLI_str_escape(propname_esc, node->name, sizeof(propname_esc));
3049   BLI_snprintf(prefix, sizeof(prefix), "nodes[\"%s\"]", propname_esc);
3050
3051   if (BKE_animdata_fix_paths_remove((ID *)ntree, prefix)) {
3052     if (bmain != nullptr) {
3053       DEG_relations_tag_update(bmain);
3054     }
3055   }
3056
3057   /* Free node itself. */
3058   node_free_node(ntree, node);
3059 }
3060
3061 static void node_socket_interface_free(bNodeTree *UNUSED(ntree),
3062                                        bNodeSocket *sock,
3063                                        const bool do_id_user)
3064 {
3065   if (sock->prop) {
3066     IDP_FreeProperty_ex(sock->prop, do_id_user);
3067   }
3068
3069   if (sock->default_value) {
3070     if (do_id_user) {
3071       socket_id_user_decrement(sock);
3072     }
3073     MEM_freeN(sock->default_value);
3074   }
3075 }
3076
3077 static void free_localized_node_groups(bNodeTree *ntree)
3078 {
3079   /* Only localized node trees store a copy for each node group tree.
3080    * Each node group tree in a localized node tree can be freed,
3081    * since it is a localized copy itself (no risk of accessing free'd
3082    * data in main, see T37939).
3083    */
3084   if (!(ntree->id.tag & LIB_TAG_LOCALIZED)) {
3085     return;
3086   }
3087
3088   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3089     if ((ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) && node->id) {
3090       bNodeTree *ngroup = (bNodeTree *)node->id;
3091       ntreeFreeTree(ngroup);
3092       MEM_freeN(ngroup);
3093     }
3094   }
3095 }
3096
3097 /* Free (or release) any data used by this nodetree. Does not free the
3098  * nodetree itself and does no ID user counting. */
3099 void ntreeFreeTree(bNodeTree *ntree)
3100 {
3101   ntree_free_data(&ntree->id);
3102   BKE_animdata_free(&ntree->id, false);
3103 }
3104
3105 void ntreeFreeEmbeddedTree(bNodeTree *ntree)
3106 {
3107   ntreeFreeTree(ntree);
3108   BKE_libblock_free_data(&ntree->id, true);
3109 }
3110
3111 void ntreeFreeLocalTree(bNodeTree *ntree)
3112 {
3113   if (ntree->id.tag & LIB_TAG_LOCALIZED) {
3114     ntreeFreeTree(ntree);
3115   }
3116   else {
3117     ntreeFreeTree(ntree);
3118     BKE_libblock_free_data(&ntree->id, true);
3119   }
3120 }
3121
3122 void ntreeFreeCache(bNodeTree *ntree)
3123 {
3124   if (ntree == nullptr) {
3125     return;
3126   }
3127
3128   if (ntree->typeinfo->free_cache) {
3129     ntree->typeinfo->free_cache(ntree);
3130   }
3131 }
3132
3133 void ntreeSetOutput(bNodeTree *ntree)
3134 {
3135   /* find the active outputs, might become tree type dependent handler */
3136   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3137     if (node->typeinfo->nclass == NODE_CLASS_OUTPUT) {
3138       /* we need a check for which output node should be tagged like this, below an exception */
3139       if (node->type == CMP_NODE_OUTPUT_FILE) {
3140         continue;
3141       }
3142
3143       int output = 0;
3144       /* there is more types having output class, each one is checked */
3145       LISTBASE_FOREACH (bNode *, tnode, &ntree->nodes) {
3146         if (tnode->typeinfo->nclass == NODE_CLASS_OUTPUT) {
3147           if (ntree->type == NTREE_COMPOSIT) {
3148             /* same type, exception for viewer */
3149             if (tnode->type == node->type ||
3150                 (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
3151                  ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))) {
3152               if (tnode->flag & NODE_DO_OUTPUT) {
3153                 output++;
3154                 if (output > 1) {
3155                   tnode->flag &= ~NODE_DO_OUTPUT;
3156                 }
3157               }
3158             }
3159           }
3160           else {
3161             /* same type */
3162             if (tnode->type == node->type) {
3163               if (tnode->flag & NODE_DO_OUTPUT) {
3164                 output++;
3165                 if (output > 1) {
3166                   tnode->flag &= ~NODE_DO_OUTPUT;
3167                 }
3168               }
3169             }
3170           }
3171         }
3172       }
3173       if (output == 0) {
3174         node->flag |= NODE_DO_OUTPUT;
3175       }
3176     }
3177
3178     /* group node outputs use this flag too */
3179     if (node->type == NODE_GROUP_OUTPUT) {
3180       int output = 0;
3181       LISTBASE_FOREACH (bNode *, tnode, &ntree->nodes) {
3182         if (tnode->type == NODE_GROUP_OUTPUT) {
3183           if (tnode->flag & NODE_DO_OUTPUT) {
3184             output++;
3185             if (output > 1) {
3186               tnode->flag &= ~NODE_DO_OUTPUT;
3187             }
3188           }
3189         }
3190       }
3191       if (output == 0) {
3192         node->flag |= NODE_DO_OUTPUT;
3193       }
3194     }
3195   }
3196
3197   /* here we could recursively set which nodes have to be done,
3198    * might be different for editor or for "real" use... */
3199 }
3200
3201 /**
3202  * Get address of potential node-tree pointer of given ID.
3203  *
3204  * \warning Using this function directly is potentially dangerous, if you don't know or are not
3205  * sure, please use `ntreeFromID()` instead.
3206  */
3207 bNodeTree **BKE_ntree_ptr_from_id(ID *id)
3208 {
3209   switch (GS(id->name)) {
3210     case ID_MA:
3211       return &((Material *)id)->nodetree;
3212     case ID_LA:
3213       return &((Light *)id)->nodetree;
3214     case ID_WO:
3215       return &((World *)id)->nodetree;
3216     case ID_TE:
3217       return &((Tex *)id)->nodetree;
3218     case ID_SCE:
3219       return &((Scene *)id)->nodetree;
3220     case ID_LS:
3221       return &((FreestyleLineStyle *)id)->nodetree;
3222     case ID_SIM:
3223       return &((Simulation *)id)->nodetree;
3224     default:
3225       return nullptr;
3226   }
3227 }
3228
3229 /* Returns the private NodeTree object of the datablock, if it has one. */
3230 bNodeTree *ntreeFromID(ID *id)
3231 {
3232   bNodeTree **nodetree = BKE_ntree_ptr_from_id(id);
3233   return (nodetree != nullptr) ? *nodetree : nullptr;
3234 }
3235
3236 bool ntreeNodeExists(const bNodeTree *ntree, const bNode *testnode)
3237 {
3238   LISTBASE_FOREACH (const bNode *, node, &ntree->nodes) {
3239     if (node == testnode) {
3240       return true;
3241     }
3242   }
3243   return false;
3244 }
3245
3246 bool ntreeOutputExists(const bNode *node, const bNodeSocket *testsock)
3247 {
3248   LISTBASE_FOREACH (const bNodeSocket *, sock, &node->outputs) {
3249     if (sock == testsock) {
3250       return true;
3251     }
3252   }
3253   return false;
3254 }
3255
3256 void ntreeNodeFlagSet(const bNodeTree *ntree, const int flag, const bool enable)
3257 {
3258   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3259     if (enable) {
3260       node->flag |= flag;
3261     }
3262     else {
3263       node->flag &= ~flag;
3264     }
3265   }
3266 }
3267
3268 /* returns localized tree for execution in threads */
3269 bNodeTree *ntreeLocalize(bNodeTree *ntree)
3270 {
3271   if (ntree) {
3272     /* Make full copy outside of Main database.
3273      * Note: previews are not copied here.
3274      */
3275     bNodeTree *ltree = (bNodeTree *)BKE_id_copy_ex(
3276         nullptr, &ntree->id, nullptr, (LIB_ID_COPY_LOCALIZE | LIB_ID_COPY_NO_ANIMDATA));
3277
3278     ltree->id.tag |= LIB_TAG_LOCALIZED;
3279
3280     LISTBASE_FOREACH (bNode *, node, &ltree->nodes) {
3281       if ((ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) && node->id) {
3282         node->id = (ID *)ntreeLocalize((bNodeTree *)node->id);
3283       }
3284     }
3285
3286     /* ensures only a single output node is enabled */
3287     ntreeSetOutput(ntree);
3288
3289     bNode *node_src = (bNode *)ntree->nodes.first;
3290     bNode *node_local = (bNode *)ltree->nodes.first;
3291     while (node_src != nullptr) {
3292       node_local->original = node_src;
3293       node_src = node_src->next;
3294       node_local = node_local->next;
3295     }
3296
3297     if (ntree->typeinfo->localize) {
3298       ntree->typeinfo->localize(ltree, ntree);
3299     }
3300
3301     return ltree;
3302   }
3303
3304   return nullptr;
3305 }
3306
3307 /* sync local composite with real tree */
3308 /* local tree is supposed to be running, be careful moving previews! */
3309 /* is called by jobs manager, outside threads, so it doesn't happen during draw */
3310 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
3311 {
3312   if (localtree && ntree) {
3313     if (ntree->typeinfo->local_sync) {
3314       ntree->typeinfo->local_sync(localtree, ntree);
3315     }
3316   }
3317 }
3318
3319 /* merge local tree results back, and free local tree */
3320 /* we have to assume the editor already changed completely */
3321 void ntreeLocalMerge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
3322 {
3323   if (ntree && localtree) {
3324     if (ntree->typeinfo->local_merge) {
3325       ntree->typeinfo->local_merge(bmain, localtree, ntree);
3326     }
3327
3328     ntreeFreeTree(localtree);
3329     MEM_freeN(localtree);
3330   }
3331 }
3332
3333 /* ************ NODE TREE INTERFACE *************** */
3334
3335 static bNodeSocket *make_socket_interface(bNodeTree *ntree,
3336                                           eNodeSocketInOut in_out,
3337                                           const char *idname,
3338                                           const char *name)
3339 {
3340   bNodeSocketType *stype = nodeSocketTypeFind(idname);
3341   int own_index = ntree->cur_index++;
3342
3343   if (stype == nullptr) {
3344     return nullptr;
3345   }
3346
3347   bNodeSocket *sock = (bNodeSocket *)MEM_callocN(sizeof(bNodeSocket), "socket template");
3348   BLI_strncpy(sock->idname, stype->idname, sizeof(sock->idname));
3349   node_socket_set_typeinfo(ntree, sock, stype);
3350   sock->in_out = in_out;
3351   sock->type = SOCK_CUSTOM; /* int type undefined by default */
3352
3353   /* assign new unique index */
3354   own_index = ntree->cur_index++;
3355   /* use the own_index as socket identifier */
3356   if (in_out == SOCK_IN) {
3357     BLI_snprintf(sock->identifier, MAX_NAME, "Input_%d", own_index);
3358   }
3359   else {
3360     BLI_snprintf(sock->identifier, MAX_NAME, "Output_%d", own_index);
3361   }
3362
3363   sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
3364
3365   BLI_strncpy(sock->name, name, NODE_MAXSTR);
3366   sock->storage = nullptr;
3367   sock->flag |= SOCK_COLLAPSED;
3368
3369   return sock;
3370 }
3371
3372 bNodeSocket *ntreeFindSocketInterface(bNodeTree *ntree,
3373                                       eNodeSocketInOut in_out,
3374                                       const char *identifier)
3375 {
3376   ListBase *sockets = (in_out == SOCK_IN) ? &ntree->inputs : &ntree->outputs;
3377   LISTBASE_FOREACH (bNodeSocket *, iosock, sockets) {
3378     if (STREQ(iosock->identifier, identifier)) {
3379       return iosock;
3380     }
3381   }
3382   return nullptr;
3383 }
3384
3385 bNodeSocket *ntreeAddSocketInterface(bNodeTree *ntree,
3386                                      eNodeSocketInOut in_out,
3387                                      const char *idname,
3388                                      const char *name)
3389 {
3390   bNodeSocket *iosock = make_socket_interface(ntree, in_out, idname, name);
3391   if (in_out == SOCK_IN) {
3392     BLI_addtail(&ntree->inputs, iosock);
3393     ntree->update |= NTREE_UPDATE_GROUP_IN;
3394   }
3395   else if (in_out == SOCK_OUT) {
3396     BLI_addtail(&ntree->outputs, iosock);
3397     ntree->update |= NTREE_UPDATE_GROUP_OUT;
3398   }
3399   return iosock;
3400 }
3401
3402 bNodeSocket *ntreeInsertSocketInterface(bNodeTree *ntree,
3403                                         eNodeSocketInOut in_out,
3404                                         const char *idname,
3405                                         bNodeSocket *next_sock,
3406                                         const char *name)
3407 {
3408   bNodeSocket *iosock = make_socket_interface(ntree, in_out, idname, name);
3409   if (in_out == SOCK_IN) {
3410     BLI_insertlinkbefore(&ntree->inputs, next_sock, iosock);
3411     ntree->update |= NTREE_UPDATE_GROUP_IN;
3412   }
3413   else if (in_out == SOCK_OUT) {
3414     BLI_insertlinkbefore(&ntree->outputs, next_sock, iosock);
3415     ntree->update |= NTREE_UPDATE_GROUP_OUT;
3416   }
3417   return iosock;
3418 }
3419
3420 struct bNodeSocket *ntreeAddSocketInterfaceFromSocket(bNodeTree *ntree,
3421                                                       bNode *from_node,
3422                                                       bNodeSocket *from_sock)
3423 {
3424   bNodeSocket *iosock = ntreeAddSocketInterface(
3425       ntree, static_cast<eNodeSocketInOut>(from_sock->in_out), from_sock->idname, from_sock->name);
3426   if (iosock) {
3427     if (iosock->typeinfo->interface_from_socket) {
3428       iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock);
3429     }
3430   }
3431   return iosock;
3432 }
3433
3434 struct bNodeSocket *ntreeInsertSocketInterfaceFromSocket(bNodeTree *ntree,
3435                                                          bNodeSocket *next_sock,
3436                                                          bNode *from_node,
3437                                                          bNodeSocket *from_sock)
3438 {
3439   bNodeSocket *iosock = ntreeInsertSocketInterface(
3440       ntree,
3441       static_cast<eNodeSocketInOut>(from_sock->in_out),
3442       from_sock->idname,
3443       next_sock,
3444       from_sock->name);
3445   if (iosock) {
3446     if (iosock->typeinfo->interface_from_socket) {
3447       iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock);
3448     }
3449   }
3450   return iosock;
3451 }
3452
3453 void ntreeRemoveSocketInterface(bNodeTree *ntree, bNodeSocket *sock)
3454 {
3455   /* this is fast, this way we don't need an in_out argument */
3456   BLI_remlink(&ntree->inputs, sock);
3457   BLI_remlink(&ntree->outputs, sock);
3458
3459   node_socket_interface_free(ntree, sock, true);
3460   MEM_freeN(sock);
3461
3462   ntree->update |= NTREE_UPDATE_GROUP;
3463 }
3464
3465 /* generates a valid RNA identifier from the node tree name */
3466 static void ntree_interface_identifier_base(bNodeTree *ntree, char *base)
3467 {
3468   /* generate a valid RNA identifier */
3469   sprintf(base, "NodeTreeInterface_%s", ntree->id.name + 2);
3470   RNA_identifier_sanitize(base, false);
3471 }
3472
3473 /* check if the identifier is already in use */
3474 static bool ntree_interface_unique_identifier_check(void *UNUSED(data), const char *identifier)
3475 {
3476   return (RNA_struct_find(identifier) != nullptr);
3477 }
3478
3479 /* generates the actual unique identifier and ui name and description */
3480 static void ntree_interface_identifier(bNodeTree *ntree,
3481                                        const char *base,
3482                                        char *identifier,
3483                                        int maxlen,
3484                                        char *name,
3485                                        char *description)
3486 {
3487   /* There is a possibility that different node tree names get mapped to the same identifier
3488    * after sanitation (e.g. "SomeGroup_A", "SomeGroup.A" both get sanitized to "SomeGroup_A").
3489    * On top of the sanitized id string add a number suffix if necessary to avoid duplicates.
3490    */
3491   identifier[0] = '\0';
3492   BLI_uniquename_cb(
3493       ntree_interface_unique_identifier_check, nullptr, base, '_', identifier, maxlen);
3494
3495   sprintf(name, "Node Tree %s Interface", ntree->id.name + 2);
3496   sprintf(description, "Interface properties of node group %s", ntree->id.name + 2);
3497 }
3498
3499 static void ntree_interface_type_create(bNodeTree *ntree)
3500 {
3501   /* strings are generated from base string + ID name, sizes are sufficient */
3502   char base[MAX_ID_NAME + 64], identifier[MAX_ID_NAME + 64], name[MAX_ID_NAME + 64],
3503       description[MAX_ID_NAME + 64];
3504
3505   /* generate a valid RNA identifier */
3506   ntree_interface_identifier_base(ntree, base);
3507   ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description);
3508
3509   /* register a subtype of PropertyGroup */
3510   StructRNA *srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_PropertyGroup);
3511   RNA_def_struct_ui_text(srna, name, description);
3512   RNA_def_struct_duplicate_pointers(&BLENDER_RNA, srna);
3513
3514   /* associate the RNA type with the node tree */
3515   ntree->interface_type = srna;
3516   RNA_struct_blender_type_set(srna, ntree);
3517
3518   /* add socket properties */
3519   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
3520     bNodeSocketType *stype = sock->typeinfo;
3521     if (stype && stype->interface_register_properties) {
3522       stype->interface_register_properties(ntree, sock, srna);
3523     }
3524   }
3525   LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
3526     bNodeSocketType *stype = sock->typeinfo;
3527     if (stype && stype->interface_register_properties) {
3528       stype->interface_register_properties(ntree, sock, srna);
3529     }
3530   }
3531 }
3532
3533 StructRNA *ntreeInterfaceTypeGet(bNodeTree *ntree, bool create)
3534 {
3535   if (ntree->interface_type) {
3536     /* strings are generated from base string + ID name, sizes are sufficient */
3537     char base[MAX_ID_NAME + 64], identifier[MAX_ID_NAME + 64], name[MAX_ID_NAME + 64],
3538         description[MAX_ID_NAME + 64];
3539
3540     /* A bit of a hack: when changing the ID name, update the RNA type identifier too,
3541      * so that the names match. This is not strictly necessary to keep it working,
3542      * but better for identifying associated NodeTree blocks and RNA types.
3543      */
3544     StructRNA *srna = ntree->interface_type;
3545
3546     ntree_interface_identifier_base(ntree, base);
3547
3548     /* RNA identifier may have a number suffix, but should start with the idbase string */
3549     if (!STREQLEN(RNA_struct_identifier(srna), base, sizeof(base))) {
3550       /* generate new unique RNA identifier from the ID name */
3551       ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description);
3552
3553       /* rename the RNA type */
3554       RNA_def_struct_free_pointers(&BLENDER_RNA, srna);
3555       RNA_def_struct_identifier(&BLENDER_RNA, srna, identifier);
3556       RNA_def_struct_ui_text(srna, name, description);
3557       RNA_def_struct_duplicate_pointers(&BLENDER_RNA, srna);
3558     }
3559   }
3560   else if (create) {
3561     ntree_interface_type_create(ntree);
3562   }
3563
3564   return ntree->interface_type;
3565 }
3566
3567 void ntreeInterfaceTypeFree(bNodeTree *ntree)
3568 {
3569   if (ntree->interface_type) {
3570     RNA_struct_free(&BLENDER_RNA, ntree->interface_type);
3571     ntree->interface_type = nullptr;
3572   }
3573 }
3574
3575 void ntreeInterfaceTypeUpdate(bNodeTree *ntree)
3576 {
3577   /* XXX it would be sufficient to just recreate all properties
3578    * instead of re-registering the whole struct type,
3579    * but there is currently no good way to do this in the RNA functions.
3580    * Overhead should be negligible.
3581    */
3582   ntreeInterfaceTypeFree(ntree);
3583   ntree_interface_type_create(ntree);
3584 }
3585
3586 /* ************ find stuff *************** */
3587
3588 bNode *ntreeFindType(const bNodeTree *ntree, int type)
3589 {
3590   if (ntree) {
3591     LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3592       if (node->type == type) {
3593         return node;
3594       }
3595     }
3596   }
3597   return nullptr;
3598 }
3599
3600 bool ntreeHasType(const bNodeTree *ntree, int type)
3601 {
3602   return ntreeFindType(ntree, type) != nullptr;
3603 }
3604
3605 bool ntreeHasTree(const bNodeTree *ntree, const bNodeTree *lookup)
3606 {
3607   if (ntree == lookup) {
3608     return true;
3609   }
3610   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3611     if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id) {
3612       if (ntreeHasTree((bNodeTree *)node->id, lookup)) {
3613         return true;
3614       }
3615     }
3616   }
3617   return false;
3618 }
3619
3620 bNodeLink *nodeFindLink(bNodeTree *ntree, const bNodeSocket *from, const bNodeSocket *to)
3621 {
3622   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
3623     if (link->fromsock == from && link->tosock == to) {
3624       return link;
3625     }
3626     if (link->fromsock == to && link->tosock == from) { /* hrms? */
3627       return link;
3628     }
3629   }
3630   return nullptr;
3631 }
3632
3633 int nodeCountSocketLinks(const bNodeTree *ntree, const bNodeSocket *sock)
3634 {
3635   int tot = 0;
3636   LISTBASE_FOREACH (const bNodeLink *, link, &ntree->links) {
3637     if (link->fromsock == sock || link->tosock == sock) {
3638       tot++;
3639     }
3640   }
3641   return tot;
3642 }
3643
3644 bNode *nodeGetActive(bNodeTree *ntree)
3645 {
3646   if (ntree == nullptr) {
3647     return nullptr;
3648   }
3649
3650   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3651     if (node->flag & NODE_ACTIVE) {
3652       return node;
3653     }
3654   }
3655   return nullptr;
3656 }
3657
3658 static bNode *node_get_active_id_recursive(bNodeInstanceKey active_key,
3659                                            bNodeInstanceKey parent_key,
3660                                            bNodeTree *ntree,
3661                                            short idtype)
3662 {
3663   if (parent_key.value == active_key.value || active_key.value == 0) {
3664     LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3665       if (node->id && GS(node->id->name) == idtype) {
3666         if (node->flag & NODE_ACTIVE_ID) {
3667           return node;
3668         }
3669       }
3670     }
3671   }
3672   else {
3673     /* no node with active ID in this tree, look inside groups */
3674     LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3675       if (node->type == NODE_GROUP) {
3676         bNodeTree *group = (bNodeTree *)node->id;
3677         if (group) {
3678           bNodeInstanceKey group_key = BKE_node_instance_key(parent_key, ntree, node);
3679           bNode *tnode = node_get_active_id_recursive(active_key, group_key, group, idtype);
3680           if (tnode) {
3681             return tnode;
3682           }
3683         }
3684       }
3685     }
3686   }
3687   return nullptr;
3688 }
3689
3690 /* two active flags, ID nodes have special flag for buttons display */
3691 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
3692 {
3693   if (ntree) {
3694     return node_get_active_id_recursive(
3695         ntree->active_viewer_key, NODE_INSTANCE_KEY_BASE, ntree, idtype);
3696   }
3697   return nullptr;
3698 }
3699
3700 bool nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
3701 {
3702   bool ok = false;
3703
3704   if (ntree == nullptr) {
3705     return ok;
3706   }
3707
3708   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3709     if (node->id && GS(node->id->name) == idtype) {
3710       if (id && ok == false && node->id == id) {
3711         node->flag |= NODE_ACTIVE_ID;
3712         ok = true;
3713       }
3714       else {
3715         node->flag &= ~NODE_ACTIVE_ID;
3716       }
3717     }
3718   }
3719
3720   /* update all groups linked from here
3721    * if active ID node has been found already,
3722    * just pass null so other matching nodes are deactivated.
3723    */
3724   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3725     if (node->type == NODE_GROUP) {
3726       ok |= nodeSetActiveID((bNodeTree *)node->id, idtype, (ok == false ? id : nullptr));
3727     }
3728   }
3729
3730   return ok;
3731 }
3732
3733 /* two active flags, ID nodes have special flag for buttons display */
3734 void nodeClearActiveID(bNodeTree *ntree, short idtype)
3735 {
3736   if (ntree == nullptr) {
3737     return;
3738   }
3739
3740   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3741     if (