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 <limits.h>
29 #include <stddef.h>
30 #include <stdlib.h>
31 #include <string.h>
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_gpencil_types.h"
39 #include "DNA_light_types.h"
40 #include "DNA_linestyle_types.h"
41 #include "DNA_material_types.h"
42 #include "DNA_node_types.h"
43 #include "DNA_scene_types.h"
44 #include "DNA_simulation_types.h"
45 #include "DNA_texture_types.h"
46 #include "DNA_world_types.h"
47
48 #include "BLI_ghash.h"
49 #include "BLI_listbase.h"
50 #include "BLI_math.h"
51 #include "BLI_path_util.h"
52 #include "BLI_string.h"
53 #include "BLI_string_utils.h"
54 #include "BLI_utildefines.h"
55
56 #include "BLT_translation.h"
57
58 #include "BKE_anim_data.h"
59 #include "BKE_animsys.h"
60 #include "BKE_colortools.h"
61 #include "BKE_global.h"
62 #include "BKE_idprop.h"
63 #include "BKE_idtype.h"
64 #include "BKE_lib_id.h"
65 #include "BKE_lib_query.h"
66 #include "BKE_main.h"
67 #include "BKE_node.h"
68 #include "BKE_simulation.h"
69
70 #include "BLI_ghash.h"
71 #include "BLI_threads.h"
72 #include "RNA_access.h"
73 #include "RNA_define.h"
74
75 #include "NOD_common.h"
76 #include "NOD_composite.h"
77 #include "NOD_function.h"
78 #include "NOD_shader.h"
79 #include "NOD_simulation.h"
80 #include "NOD_socket.h"
81 #include "NOD_texture.h"
82
83 #include "DEG_depsgraph.h"
84 #include "DEG_depsgraph_build.h"
85
86 #include "BLO_read_write.h"
87
88 #define NODE_DEFAULT_MAX_WIDTH 700
89
90 /* Fallback types for undefined tree, nodes, sockets */
91 static bNodeTreeType NodeTreeTypeUndefined;
92 bNodeType NodeTypeUndefined;
93 bNodeSocketType NodeSocketTypeUndefined;
94
95 static CLG_LogRef LOG = {"bke.node"};
96
97 static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo);
98 static void node_socket_copy(bNodeSocket *sock_dst, const bNodeSocket *sock_src, const int flag);
99 static void free_localized_node_groups(bNodeTree *ntree);
100 static void node_free_node(bNodeTree *ntree, bNode *node);
101 static void node_socket_interface_free(bNodeTree *UNUSED(ntree),
102 bNodeSocket *sock,
103 const bool do_id_user);
104
ntree_init_data(ID * id)105 static void ntree_init_data(ID *id)
106 {
107 bNodeTree *ntree = (bNodeTree *)id;
108 ntree_set_typeinfo(ntree, NULL);
109 }
110
ntree_copy_data(Main * UNUSED (bmain),ID * id_dst,const ID * id_src,const int flag)111 static void ntree_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
112 {
113 bNodeTree *ntree_dst = (bNodeTree *)id_dst;
114 const bNodeTree *ntree_src = (const bNodeTree *)id_src;
115
116 /* We never handle usercount here for own data. */
117 const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
118
119 /* in case a running nodetree is copied */
120 ntree_dst->execdata = NULL;
121
122 BLI_listbase_clear(&ntree_dst->nodes);
123 BLI_listbase_clear(&ntree_dst->links);
124
125 /* Since source nodes and sockets are unique pointers we can put everything in a single map. */
126 GHash *new_pointers = BLI_ghash_ptr_new(__func__);
127
128 LISTBASE_FOREACH (const bNode *, node_src, &ntree_src->nodes) {
129 bNode *new_node = BKE_node_copy_ex(ntree_dst, node_src, flag_subdata, true);
130 BLI_ghash_insert(new_pointers, (void *)node_src, new_node);
131 /* Store mapping to inputs. */
132 bNodeSocket *new_input_sock = new_node->inputs.first;
133 const bNodeSocket *input_sock_src = node_src->inputs.first;
134 while (new_input_sock != NULL) {
135 BLI_ghash_insert(new_pointers, (void *)input_sock_src, new_input_sock);
136 new_input_sock = new_input_sock->next;
137 input_sock_src = input_sock_src->next;
138 }
139 /* Store mapping to outputs. */
140 bNodeSocket *new_output_sock = new_node->outputs.first;
141 const bNodeSocket *output_sock_src = node_src->outputs.first;
142 while (new_output_sock != NULL) {
143 BLI_ghash_insert(new_pointers, (void *)output_sock_src, new_output_sock);
144 new_output_sock = new_output_sock->next;
145 output_sock_src = output_sock_src->next;
146 }
147 }
148
149 /* copy links */
150 BLI_duplicatelist(&ntree_dst->links, &ntree_src->links);
151 LISTBASE_FOREACH (bNodeLink *, link_dst, &ntree_dst->links) {
152 link_dst->fromnode = BLI_ghash_lookup_default(new_pointers, link_dst->fromnode, NULL);
153 link_dst->fromsock = BLI_ghash_lookup_default(new_pointers, link_dst->fromsock, NULL);
154 link_dst->tonode = BLI_ghash_lookup_default(new_pointers, link_dst->tonode, NULL);
155 link_dst->tosock = BLI_ghash_lookup_default(new_pointers, link_dst->tosock, NULL);
156 /* update the link socket's pointer */
157 if (link_dst->tosock) {
158 link_dst->tosock->link = link_dst;
159 }
160 }
161
162 /* copy interface sockets */
163 BLI_duplicatelist(&ntree_dst->inputs, &ntree_src->inputs);
164 bNodeSocket *sock_dst, *sock_src;
165 for (sock_dst = ntree_dst->inputs.first, sock_src = ntree_src->inputs.first; sock_dst != NULL;
166 sock_dst = sock_dst->next, sock_src = sock_src->next) {
167 node_socket_copy(sock_dst, sock_src, flag_subdata);
168 }
169
170 BLI_duplicatelist(&ntree_dst->outputs, &ntree_src->outputs);
171 for (sock_dst = ntree_dst->outputs.first, sock_src = ntree_src->outputs.first; sock_dst != NULL;
172 sock_dst = sock_dst->next, sock_src = sock_src->next) {
173 node_socket_copy(sock_dst, sock_src, flag_subdata);
174 }
175
176 /* copy preview hash */
177 if (ntree_src->previews && (flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
178 bNodeInstanceHashIterator iter;
179
180 ntree_dst->previews = BKE_node_instance_hash_new("node previews");
181
182 NODE_INSTANCE_HASH_ITER (iter, ntree_src->previews) {
183 bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
184 bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
185 BKE_node_instance_hash_insert(ntree_dst->previews, key, BKE_node_preview_copy(preview));
186 }
187 }
188 else {
189 ntree_dst->previews = NULL;
190 }
191
192 /* update node->parent pointers */
193 for (bNode *node_dst = ntree_dst->nodes.first, *node_src = ntree_src->nodes.first; node_dst;
194 node_dst = node_dst->next, node_src = node_src->next) {
195 if (node_dst->parent) {
196 node_dst->parent = BLI_ghash_lookup_default(new_pointers, node_dst->parent, NULL);
197 }
198 }
199
200 BLI_ghash_free(new_pointers, NULL, NULL);
201
202 /* node tree will generate its own interface type */
203 ntree_dst->interface_type = NULL;
204 }
205
ntree_free_data(ID * id)206 static void ntree_free_data(ID *id)
207 {
208 bNodeTree *ntree = (bNodeTree *)id;
209
210 /* XXX hack! node trees should not store execution graphs at all.
211 * This should be removed when old tree types no longer require it.
212 * Currently the execution data for texture nodes remains in the tree
213 * after execution, until the node tree is updated or freed.
214 */
215 if (ntree->execdata) {
216 switch (ntree->type) {
217 case NTREE_SHADER:
218 ntreeShaderEndExecTree(ntree->execdata);
219 break;
220 case NTREE_TEXTURE:
221 ntreeTexEndExecTree(ntree->execdata);
222 ntree->execdata = NULL;
223 break;
224 }
225 }
226
227 /* XXX not nice, but needed to free localized node groups properly */
228 free_localized_node_groups(ntree);
229
230 /* unregister associated RNA types */
231 ntreeInterfaceTypeFree(ntree);
232
233 BLI_freelistN(&ntree->links); /* do first, then unlink_node goes fast */
234
235 LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) {
236 node_free_node(ntree, node);
237 }
238
239 /* free interface sockets */
240 LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &ntree->inputs) {
241 node_socket_interface_free(ntree, sock, false);
242 MEM_freeN(sock);
243 }
244 LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &ntree->outputs) {
245 node_socket_interface_free(ntree, sock, false);
246 MEM_freeN(sock);
247 }
248
249 /* free preview hash */
250 if (ntree->previews) {
251 BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
252 }
253
254 if (ntree->id.tag & LIB_TAG_LOCALIZED) {
255 BKE_libblock_free_data(&ntree->id, true);
256 }
257 }
258
library_foreach_node_socket(LibraryForeachIDData * data,bNodeSocket * sock)259 static void library_foreach_node_socket(LibraryForeachIDData *data, bNodeSocket *sock)
260 {
261 IDP_foreach_property(
262 sock->prop, IDP_TYPE_FILTER_ID, BKE_lib_query_idpropertiesForeachIDLink_callback, data);
263
264 switch ((eNodeSocketDatatype)sock->type) {
265 case SOCK_OBJECT: {
266 bNodeSocketValueObject *default_value = sock->default_value;
267 BKE_LIB_FOREACHID_PROCESS(data, default_value->value, IDWALK_CB_USER);
268 break;
269 }
270 case SOCK_IMAGE: {
271 bNodeSocketValueImage *default_value = sock->default_value;
272 BKE_LIB_FOREACHID_PROCESS(data, default_value->value, IDWALK_CB_USER);
273 break;
274 }
275 case SOCK_FLOAT:
276 case SOCK_VECTOR:
277 case SOCK_RGBA:
278 case SOCK_BOOLEAN:
279 case SOCK_INT:
280 case SOCK_STRING:
281 case __SOCK_MESH:
282 case SOCK_CUSTOM:
283 case SOCK_SHADER:
284 break;
285 }
286 }
287
node_foreach_id(ID * id,LibraryForeachIDData * data)288 static void node_foreach_id(ID *id, LibraryForeachIDData *data)
289 {
290 bNodeTree *ntree = (bNodeTree *)id;
291
292 BKE_LIB_FOREACHID_PROCESS(data, ntree->gpd, IDWALK_CB_USER);
293
294 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
295 BKE_LIB_FOREACHID_PROCESS_ID(data, node->id, IDWALK_CB_USER);
296
297 IDP_foreach_property(
298 node->prop, IDP_TYPE_FILTER_ID, BKE_lib_query_idpropertiesForeachIDLink_callback, data);
299 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
300 library_foreach_node_socket(data, sock);
301 }
302 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
303 library_foreach_node_socket(data, sock);
304 }
305 }
306
307 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
308 library_foreach_node_socket(data, sock);
309 }
310 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
311 library_foreach_node_socket(data, sock);
312 }
313 }
314
node_foreach_cache(ID * id,IDTypeForeachCacheFunctionCallback function_callback,void * user_data)315 static void node_foreach_cache(ID *id,
316 IDTypeForeachCacheFunctionCallback function_callback,
317 void *user_data)
318 {
319 bNodeTree *nodetree = (bNodeTree *)id;
320 IDCacheKey key = {
321 .id_session_uuid = id->session_uuid,
322 .offset_in_ID = offsetof(bNodeTree, previews),
323 .cache_v = nodetree->previews,
324 };
325
326 /* TODO, see also `direct_link_nodetree()` in readfile.c. */
327 #if 0
328 function_callback(id, &key, (void **)&nodetree->previews, 0, user_data);
329 #endif
330
331 if (nodetree->type == NTREE_COMPOSIT) {
332 LISTBASE_FOREACH (bNode *, node, &nodetree->nodes) {
333 if (node->type == CMP_NODE_MOVIEDISTORTION) {
334 key.offset_in_ID = (size_t)BLI_ghashutil_strhash_p(node->name);
335 key.cache_v = node->storage;
336 function_callback(id, &key, (void **)&node->storage, 0, user_data);
337 }
338 }
339 }
340 }
341
write_node_socket_default_value(BlendWriter * writer,bNodeSocket * sock)342 static void write_node_socket_default_value(BlendWriter *writer, bNodeSocket *sock)
343 {
344 if (sock->default_value == NULL) {
345 return;
346 }
347
348 switch ((eNodeSocketDatatype)sock->type) {
349 case SOCK_FLOAT:
350 BLO_write_struct(writer, bNodeSocketValueFloat, sock->default_value);
351 break;
352 case SOCK_VECTOR:
353 BLO_write_struct(writer, bNodeSocketValueVector, sock->default_value);
354 break;
355 case SOCK_RGBA:
356 BLO_write_struct(writer, bNodeSocketValueRGBA, sock->default_value);
357 break;
358 case SOCK_BOOLEAN:
359 BLO_write_struct(writer, bNodeSocketValueBoolean, sock->default_value);
360 break;
361 case SOCK_INT:
362 BLO_write_struct(writer, bNodeSocketValueInt, sock->default_value);
363 break;
364 case SOCK_STRING:
365 BLO_write_struct(writer, bNodeSocketValueString, sock->default_value);
366 break;
367 case SOCK_OBJECT:
368 BLO_write_struct(writer, bNodeSocketValueObject, sock->default_value);
369 break;
370 case SOCK_IMAGE:
371 BLO_write_struct(writer, bNodeSocketValueImage, sock->default_value);
372 break;
373 case __SOCK_MESH:
374 case SOCK_CUSTOM:
375 case SOCK_SHADER:
376 BLI_assert(false);
377 break;
378 }
379 }
380
write_node_socket(BlendWriter * writer,bNodeSocket * sock)381 static void write_node_socket(BlendWriter *writer, bNodeSocket *sock)
382 {
383 /* actual socket writing */
384 BLO_write_struct(writer, bNodeSocket, sock);
385
386 if (sock->prop) {
387 IDP_BlendWrite(writer, sock->prop);
388 }
389
390 write_node_socket_default_value(writer, sock);
391 }
write_node_socket_interface(BlendWriter * writer,bNodeSocket * sock)392 static void write_node_socket_interface(BlendWriter *writer, bNodeSocket *sock)
393 {
394 /* actual socket writing */
395 BLO_write_struct(writer, bNodeSocket, sock);
396
397 if (sock->prop) {
398 IDP_BlendWrite(writer, sock->prop);
399 }
400
401 write_node_socket_default_value(writer, sock);
402 }
403
404 /* this is only direct data, tree itself should have been written */
ntreeBlendWrite(BlendWriter * writer,bNodeTree * ntree)405 void ntreeBlendWrite(BlendWriter *writer, bNodeTree *ntree)
406 {
407 /* for link_list() speed, we write per list */
408
409 if (ntree->adt) {
410 BKE_animdata_blend_write(writer, ntree->adt);
411 }
412
413 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
414 BLO_write_struct(writer, bNode, node);
415
416 if (node->prop) {
417 IDP_BlendWrite(writer, node->prop);
418 }
419
420 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
421 write_node_socket(writer, sock);
422 }
423 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
424 write_node_socket(writer, sock);
425 }
426
427 LISTBASE_FOREACH (bNodeLink *, link, &node->internal_links) {
428 BLO_write_struct(writer, bNodeLink, link);
429 }
430
431 if (node->storage) {
432 /* could be handlerized at some point, now only 1 exception still */
433 if ((ntree->type == NTREE_SHADER) &&
434 ELEM(node->type, SH_NODE_CURVE_VEC, SH_NODE_CURVE_RGB)) {
435 BKE_curvemapping_blend_write(writer, node->storage);
436 }
437 else if (ntree->type == NTREE_SHADER && (node->type == SH_NODE_SCRIPT)) {
438 NodeShaderScript *nss = (NodeShaderScript *)node->storage;
439 if (nss->bytecode) {
440 BLO_write_string(writer, nss->bytecode);
441 }
442 BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
443 }
444 else if ((ntree->type == NTREE_COMPOSIT) && ELEM(node->type,
445 CMP_NODE_TIME,
446 CMP_NODE_CURVE_VEC,
447 CMP_NODE_CURVE_RGB,
448 CMP_NODE_HUECORRECT)) {
449 BKE_curvemapping_blend_write(writer, node->storage);
450 }
451 else if ((ntree->type == NTREE_TEXTURE) &&
452 (node->type == TEX_NODE_CURVE_RGB || node->type == TEX_NODE_CURVE_TIME)) {
453 BKE_curvemapping_blend_write(writer, node->storage);
454 }
455 else if ((ntree->type == NTREE_COMPOSIT) && (node->type == CMP_NODE_MOVIEDISTORTION)) {
456 /* pass */
457 }
458 else if ((ntree->type == NTREE_COMPOSIT) && (node->type == CMP_NODE_GLARE)) {
459 /* Simple forward compatibility for fix for T50736.
460 * Not ideal (there is no ideal solution here), but should do for now. */
461 NodeGlare *ndg = node->storage;
462 /* Not in undo case. */
463 if (!BLO_write_is_undo(writer)) {
464 switch (ndg->type) {
465 case 2: /* Grrrr! magic numbers :( */
466 ndg->angle = ndg->streaks;
467 break;
468 case 0:
469 ndg->angle = ndg->star_45;
470 break;
471 default:
472 break;
473 }
474 }
475 BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
476 }
477 else if ((ntree->type == NTREE_COMPOSIT) && (node->type == CMP_NODE_CRYPTOMATTE)) {
478 NodeCryptomatte *nc = (NodeCryptomatte *)node->storage;
479 if (nc->matte_id) {
480 BLO_write_string(writer, nc->matte_id);
481 }
482 BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
483 }
484 else if (node->typeinfo != &NodeTypeUndefined) {
485 BLO_write_struct_by_name(writer, node->typeinfo->storagename, node->storage);
486 }
487 }
488
489 if (node->type == CMP_NODE_OUTPUT_FILE) {
490 /* inputs have own storage data */
491 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
492 BLO_write_struct(writer, NodeImageMultiFileSocket, sock->storage);
493 }
494 }
495 if (ELEM(node->type, CMP_NODE_IMAGE, CMP_NODE_R_LAYERS)) {
496 /* write extra socket info */
497 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
498 BLO_write_struct(writer, NodeImageLayer, sock->storage);
499 }
500 }
501 }
502
503 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
504 BLO_write_struct(writer, bNodeLink, link);
505 }
506
507 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
508 write_node_socket_interface(writer, sock);
509 }
510 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
511 write_node_socket_interface(writer, sock);
512 }
513 }
514
ntree_blend_write(BlendWriter * writer,ID * id,const void * id_address)515 static void ntree_blend_write(BlendWriter *writer, ID *id, const void *id_address)
516 {
517 bNodeTree *ntree = (bNodeTree *)id;
518 if (ntree->id.us > 0 || BLO_write_is_undo(writer)) {
519 /* Clean up, important in undo case to reduce false detection of changed datablocks. */
520 ntree->init = 0; /* to set callbacks and force setting types */
521 ntree->is_updating = false;
522 ntree->typeinfo = NULL;
523 ntree->interface_type = NULL;
524 ntree->progress = NULL;
525 ntree->execdata = NULL;
526
527 BLO_write_id_struct(writer, bNodeTree, id_address, &ntree->id);
528 /* Note that trees directly used by other IDs (materials etc.) are not 'real' ID, they cannot
529 * be linked, etc., so we write actual id data here only, for 'real' ID trees. */
530 BKE_id_blend_write(writer, &ntree->id);
531
532 ntreeBlendWrite(writer, ntree);
533 }
534 }
535
direct_link_node_socket(BlendDataReader * reader,bNodeSocket * sock)536 static void direct_link_node_socket(BlendDataReader *reader, bNodeSocket *sock)
537 {
538 BLO_read_data_address(reader, &sock->prop);
539 IDP_BlendDataRead(reader, &sock->prop);
540
541 BLO_read_data_address(reader, &sock->link);
542 sock->typeinfo = NULL;
543 BLO_read_data_address(reader, &sock->storage);
544 BLO_read_data_address(reader, &sock->default_value);
545 sock->cache = NULL;
546 }
547
548 /* ntree itself has been read! */
ntreeBlendReadData(BlendDataReader * reader,bNodeTree * ntree)549 void ntreeBlendReadData(BlendDataReader *reader, bNodeTree *ntree)
550 {
551 /* note: writing and reading goes in sync, for speed */
552 ntree->init = 0; /* to set callbacks and force setting types */
553 ntree->is_updating = false;
554 ntree->typeinfo = NULL;
555 ntree->interface_type = NULL;
556
557 ntree->progress = NULL;
558 ntree->execdata = NULL;
559
560 BLO_read_data_address(reader, &ntree->adt);
561 BKE_animdata_blend_read_data(reader, ntree->adt);
562
563 BLO_read_list(reader, &ntree->nodes);
564 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
565 node->typeinfo = NULL;
566
567 BLO_read_list(reader, &node->inputs);
568 BLO_read_list(reader, &node->outputs);
569
570 BLO_read_data_address(reader, &node->prop);
571 IDP_BlendDataRead(reader, &node->prop);
572
573 BLO_read_list(reader, &node->internal_links);
574 LISTBASE_FOREACH (bNodeLink *, link, &node->internal_links) {
575 BLO_read_data_address(reader, &link->fromnode);
576 BLO_read_data_address(reader, &link->fromsock);
577 BLO_read_data_address(reader, &link->tonode);
578 BLO_read_data_address(reader, &link->tosock);
579 }
580
581 if (node->type == CMP_NODE_MOVIEDISTORTION) {
582 /* Do nothing, this is runtime cache and hence handled by generic code using
583 * `IDTypeInfo.foreach_cache` callback. */
584 }
585 else {
586 BLO_read_data_address(reader, &node->storage);
587 }
588
589 if (node->storage) {
590 /* could be handlerized at some point */
591 switch (node->type) {
592 case SH_NODE_CURVE_VEC:
593 case SH_NODE_CURVE_RGB:
594 case CMP_NODE_TIME:
595 case CMP_NODE_CURVE_VEC:
596 case CMP_NODE_CURVE_RGB:
597 case CMP_NODE_HUECORRECT:
598 case TEX_NODE_CURVE_RGB:
599 case TEX_NODE_CURVE_TIME: {
600 BKE_curvemapping_blend_read(reader, node->storage);
601 break;
602 }
603 case SH_NODE_SCRIPT: {
604 NodeShaderScript *nss = (NodeShaderScript *)node->storage;
605 BLO_read_data_address(reader, &nss->bytecode);
606 break;
607 }
608 case SH_NODE_TEX_POINTDENSITY: {
609 NodeShaderTexPointDensity *npd = (NodeShaderTexPointDensity *)node->storage;
610 memset(&npd->pd, 0, sizeof(npd->pd));
611 break;
612 }
613 case SH_NODE_TEX_IMAGE: {
614 NodeTexImage *tex = (NodeTexImage *)node->storage;
615 tex->iuser.ok = 1;
616 tex->iuser.scene = NULL;
617 break;
618 }
619 case SH_NODE_TEX_ENVIRONMENT: {
620 NodeTexEnvironment *tex = (NodeTexEnvironment *)node->storage;
621 tex->iuser.ok = 1;
622 tex->iuser.scene = NULL;
623 break;
624 }
625 case CMP_NODE_IMAGE:
626 case CMP_NODE_R_LAYERS:
627 case CMP_NODE_VIEWER:
628 case CMP_NODE_SPLITVIEWER: {
629 ImageUser *iuser = node->storage;
630 iuser->ok = 1;
631 iuser->scene = NULL;
632 break;
633 }
634 case CMP_NODE_CRYPTOMATTE: {
635 NodeCryptomatte *nc = (NodeCryptomatte *)node->storage;
636 BLO_read_data_address(reader, &nc->matte_id);
637 break;
638 }
639 case TEX_NODE_IMAGE: {
640 ImageUser *iuser = node->storage;
641 iuser->ok = 1;
642 iuser->scene = NULL;
643 break;
644 }
645 default:
646 break;
647 }
648 }
649 }
650 BLO_read_list(reader, &ntree->links);
651
652 /* and we connect the rest */
653 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
654 BLO_read_data_address(reader, &node->parent);
655 node->lasty = 0;
656
657 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
658 direct_link_node_socket(reader, sock);
659 }
660 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
661 direct_link_node_socket(reader, sock);
662 }
663 }
664
665 /* interface socket lists */
666 BLO_read_list(reader, &ntree->inputs);
667 BLO_read_list(reader, &ntree->outputs);
668 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
669 direct_link_node_socket(reader, sock);
670 }
671 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
672 direct_link_node_socket(reader, sock);
673 }
674
675 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
676 BLO_read_data_address(reader, &link->fromnode);
677 BLO_read_data_address(reader, &link->tonode);
678 BLO_read_data_address(reader, &link->fromsock);
679 BLO_read_data_address(reader, &link->tosock);
680 }
681
682 /* TODO, should be dealt by new generic cache handling of IDs... */
683 ntree->previews = NULL;
684
685 /* type verification is in lib-link */
686 }
687
ntree_blend_read_data(BlendDataReader * reader,ID * id)688 static void ntree_blend_read_data(BlendDataReader *reader, ID *id)
689 {
690 bNodeTree *ntree = (bNodeTree *)id;
691 ntreeBlendReadData(reader, ntree);
692 }
693
lib_link_node_socket(BlendLibReader * reader,Library * lib,bNodeSocket * sock)694 static void lib_link_node_socket(BlendLibReader *reader, Library *lib, bNodeSocket *sock)
695 {
696 IDP_BlendReadLib(reader, sock->prop);
697
698 switch ((eNodeSocketDatatype)sock->type) {
699 case SOCK_OBJECT: {
700 bNodeSocketValueObject *default_value = sock->default_value;
701 BLO_read_id_address(reader, lib, &default_value->value);
702 break;
703 }
704 case SOCK_IMAGE: {
705 bNodeSocketValueImage *default_value = sock->default_value;
706 BLO_read_id_address(reader, lib, &default_value->value);
707 break;
708 }
709 case SOCK_FLOAT:
710 case SOCK_VECTOR:
711 case SOCK_RGBA:
712 case SOCK_BOOLEAN:
713 case SOCK_INT:
714 case SOCK_STRING:
715 case __SOCK_MESH:
716 case SOCK_CUSTOM:
717 case SOCK_SHADER:
718 break;
719 }
720 }
721
lib_link_node_sockets(BlendLibReader * reader,Library * lib,ListBase * sockets)722 static void lib_link_node_sockets(BlendLibReader *reader, Library *lib, ListBase *sockets)
723 {
724 LISTBASE_FOREACH (bNodeSocket *, sock, sockets) {
725 lib_link_node_socket(reader, lib, sock);
726 }
727 }
728
ntreeBlendReadLib(struct BlendLibReader * reader,struct bNodeTree * ntree)729 void ntreeBlendReadLib(struct BlendLibReader *reader, struct bNodeTree *ntree)
730 {
731 Library *lib = ntree->id.lib;
732
733 BLO_read_id_address(reader, lib, &ntree->gpd);
734
735 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
736 /* Link ID Properties -- and copy this comment EXACTLY for easy finding
737 * of library blocks that implement this.*/
738 IDP_BlendReadLib(reader, node->prop);
739
740 BLO_read_id_address(reader, lib, &node->id);
741
742 lib_link_node_sockets(reader, lib, &node->inputs);
743 lib_link_node_sockets(reader, lib, &node->outputs);
744 }
745
746 lib_link_node_sockets(reader, lib, &ntree->inputs);
747 lib_link_node_sockets(reader, lib, &ntree->outputs);
748
749 /* Set node->typeinfo pointers. This is done in lib linking, after the
750 * first versioning that can change types still without functions that
751 * update the typeinfo pointers. Versioning after lib linking needs
752 * these top be valid. */
753 ntreeSetTypes(NULL, ntree);
754
755 /* For nodes with static socket layout, add/remove sockets as needed
756 * to match the static layout. */
757 if (!BLO_read_lib_is_undo(reader)) {
758 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
759 node_verify_socket_templates(ntree, node);
760 }
761 }
762 }
763
ntree_blend_read_lib(BlendLibReader * reader,ID * id)764 static void ntree_blend_read_lib(BlendLibReader *reader, ID *id)
765 {
766 bNodeTree *ntree = (bNodeTree *)id;
767 ntreeBlendReadLib(reader, ntree);
768 }
769
expand_node_socket(BlendExpander * expander,bNodeSocket * sock)770 static void expand_node_socket(BlendExpander *expander, bNodeSocket *sock)
771 {
772 IDP_BlendReadExpand(expander, sock->prop);
773
774 if (sock->default_value != NULL) {
775
776 switch ((eNodeSocketDatatype)sock->type) {
777 case SOCK_OBJECT: {
778 bNodeSocketValueObject *default_value = sock->default_value;
779 BLO_expand(expander, default_value->value);
780 break;
781 }
782 case SOCK_IMAGE: {
783 bNodeSocketValueImage *default_value = sock->default_value;
784 BLO_expand(expander, default_value->value);
785 break;
786 }
787 case SOCK_FLOAT:
788 case SOCK_VECTOR:
789 case SOCK_RGBA:
790 case SOCK_BOOLEAN:
791 case SOCK_INT:
792 case SOCK_STRING:
793 case __SOCK_MESH:
794 case SOCK_CUSTOM:
795 case SOCK_SHADER:
796 break;
797 }
798 }
799 }
800
expand_node_sockets(BlendExpander * expander,ListBase * sockets)801 static void expand_node_sockets(BlendExpander *expander, ListBase *sockets)
802 {
803 LISTBASE_FOREACH (bNodeSocket *, sock, sockets) {
804 expand_node_socket(expander, sock);
805 }
806 }
807
ntreeBlendReadExpand(BlendExpander * expander,bNodeTree * ntree)808 void ntreeBlendReadExpand(BlendExpander *expander, bNodeTree *ntree)
809 {
810 if (ntree->gpd) {
811 BLO_expand(expander, ntree->gpd);
812 }
813
814 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
815 if (node->id && node->type != CMP_NODE_R_LAYERS) {
816 BLO_expand(expander, node->id);
817 }
818
819 IDP_BlendReadExpand(expander, node->prop);
820
821 expand_node_sockets(expander, &node->inputs);
822 expand_node_sockets(expander, &node->outputs);
823 }
824
825 expand_node_sockets(expander, &ntree->inputs);
826 expand_node_sockets(expander, &ntree->outputs);
827 }
828
ntree_blend_read_expand(BlendExpander * expander,ID * id)829 static void ntree_blend_read_expand(BlendExpander *expander, ID *id)
830 {
831 bNodeTree *ntree = (bNodeTree *)id;
832 ntreeBlendReadExpand(expander, ntree);
833 }
834
835 IDTypeInfo IDType_ID_NT = {
836 .id_code = ID_NT,
837 .id_filter = FILTER_ID_NT,
838 .main_listbase_index = INDEX_ID_NT,
839 .struct_size = sizeof(bNodeTree),
840 .name = "NodeTree",
841 .name_plural = "node_groups",
842 .translation_context = BLT_I18NCONTEXT_ID_NODETREE,
843 .flags = 0,
844
845 .init_data = ntree_init_data,
846 .copy_data = ntree_copy_data,
847 .free_data = ntree_free_data,
848 .make_local = NULL,
849 .foreach_id = node_foreach_id,
850 .foreach_cache = node_foreach_cache,
851
852 .blend_write = ntree_blend_write,
853 .blend_read_data = ntree_blend_read_data,
854 .blend_read_lib = ntree_blend_read_lib,
855 .blend_read_expand = ntree_blend_read_expand,
856 };
857
node_add_sockets_from_type(bNodeTree * ntree,bNode * node,bNodeType * ntype)858 static void node_add_sockets_from_type(bNodeTree *ntree, bNode *node, bNodeType *ntype)
859 {
860 bNodeSocketTemplate *sockdef;
861 /* bNodeSocket *sock; */ /* UNUSED */
862
863 if (ntype->inputs) {
864 sockdef = ntype->inputs;
865 while (sockdef->type != -1) {
866 /* sock = */ node_add_socket_from_template(ntree, node, sockdef, SOCK_IN);
867
868 sockdef++;
869 }
870 }
871 if (ntype->outputs) {
872 sockdef = ntype->outputs;
873 while (sockdef->type != -1) {
874 /* sock = */ node_add_socket_from_template(ntree, node, sockdef, SOCK_OUT);
875
876 sockdef++;
877 }
878 }
879 }
880
881 /* Note: This function is called to initialize node data based on the type.
882 * The bNodeType may not be registered at creation time of the node,
883 * so this can be delayed until the node type gets registered.
884 */
node_init(const struct bContext * C,bNodeTree * ntree,bNode * node)885 static void node_init(const struct bContext *C, bNodeTree *ntree, bNode *node)
886 {
887 bNodeType *ntype = node->typeinfo;
888 if (ntype == &NodeTypeUndefined) {
889 return;
890 }
891
892 /* only do this once */
893 if (node->flag & NODE_INIT) {
894 return;
895 }
896
897 node->flag = NODE_SELECT | NODE_OPTIONS | ntype->flag;
898 node->width = ntype->width;
899 node->miniwidth = 42.0f;
900 node->height = ntype->height;
901 node->color[0] = node->color[1] = node->color[2] = 0.608; /* default theme color */
902 /* initialize the node name with the node label.
903 * note: do this after the initfunc so nodes get their data set which may be used in naming
904 * (node groups for example) */
905 /* XXX Do not use nodeLabel() here, it returns translated content for UI,
906 * which should *only* be used in UI, *never* in data...
907 * Data have their own translation option!
908 * This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler
909 * than adding "do_translate" flags to this func (and labelfunc() as well). */
910 BLI_strncpy(node->name, DATA_(ntype->ui_name), NODE_MAXSTR);
911 nodeUniqueName(ntree, node);
912
913 node_add_sockets_from_type(ntree, node, ntype);
914
915 if (ntype->initfunc != NULL) {
916 ntype->initfunc(ntree, node);
917 }
918
919 if (ntree->typeinfo->node_add_init != NULL) {
920 ntree->typeinfo->node_add_init(ntree, node);
921 }
922
923 if (node->id) {
924 id_us_plus(node->id);
925 }
926
927 /* extra init callback */
928 if (ntype->initfunc_api) {
929 PointerRNA ptr;
930 RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
931
932 /* XXX Warning: context can be NULL in case nodes are added in do_versions.
933 * Delayed init is not supported for nodes with context-based initfunc_api atm.
934 */
935 BLI_assert(C != NULL);
936 ntype->initfunc_api(C, &ptr);
937 }
938
939 node->flag |= NODE_INIT;
940 }
941
ntree_set_typeinfo(bNodeTree * ntree,bNodeTreeType * typeinfo)942 static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo)
943 {
944 if (typeinfo) {
945 ntree->typeinfo = typeinfo;
946
947 /* deprecated integer type */
948 ntree->type = typeinfo->type;
949 }
950 else {
951 ntree->typeinfo = &NodeTreeTypeUndefined;
952
953 ntree->init &= ~NTREE_TYPE_INIT;
954 }
955 }
956
node_set_typeinfo(const struct bContext * C,bNodeTree * ntree,bNode * node,bNodeType * typeinfo)957 static void node_set_typeinfo(const struct bContext *C,
958 bNodeTree *ntree,
959 bNode *node,
960 bNodeType *typeinfo)
961 {
962 /* for nodes saved in older versions storage can get lost, make undefined then */
963 if (node->flag & NODE_INIT) {
964 if (typeinfo && typeinfo->storagename[0] && !node->storage) {
965 typeinfo = NULL;
966 }
967 }
968
969 if (typeinfo) {
970 node->typeinfo = typeinfo;
971
972 /* deprecated integer type */
973 node->type = typeinfo->type;
974
975 /* initialize the node if necessary */
976 node_init(C, ntree, node);
977 }
978 else {
979 node->typeinfo = &NodeTypeUndefined;
980
981 ntree->init &= ~NTREE_TYPE_INIT;
982 }
983 }
984
node_socket_set_typeinfo(bNodeTree * ntree,bNodeSocket * sock,bNodeSocketType * typeinfo)985 static void node_socket_set_typeinfo(bNodeTree *ntree,
986 bNodeSocket *sock,
987 bNodeSocketType *typeinfo)
988 {
989 if (typeinfo) {
990 sock->typeinfo = typeinfo;
991
992 /* deprecated integer type */
993 sock->type = typeinfo->type;
994
995 if (sock->default_value == NULL) {
996 /* initialize the default_value pointer used by standard socket types */
997 node_socket_init_default_value(sock);
998 }
999 }
1000 else {
1001 sock->typeinfo = &NodeSocketTypeUndefined;
1002
1003 ntree->init &= ~NTREE_TYPE_INIT;
1004 }
1005 }
1006
1007 /* Set specific typeinfo pointers in all node trees on register/unregister */
update_typeinfo(Main * bmain,const struct bContext * C,bNodeTreeType * treetype,bNodeType * nodetype,bNodeSocketType * socktype,bool unregister)1008 static void update_typeinfo(Main *bmain,
1009 const struct bContext *C,
1010 bNodeTreeType *treetype,
1011 bNodeType *nodetype,
1012 bNodeSocketType *socktype,
1013 bool unregister)
1014 {
1015 if (!bmain) {
1016 return;
1017 }
1018
1019 FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1020 ntree->init |= NTREE_TYPE_INIT;
1021
1022 if (treetype && STREQ(ntree->idname, treetype->idname)) {
1023 ntree_set_typeinfo(ntree, unregister ? NULL : treetype);
1024 }
1025
1026 /* initialize nodes */
1027 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1028 if (nodetype && STREQ(node->idname, nodetype->idname)) {
1029 node_set_typeinfo(C, ntree, node, unregister ? NULL : nodetype);
1030 }
1031
1032 /* initialize node sockets */
1033 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
1034 if (socktype && STREQ(sock->idname, socktype->idname)) {
1035 node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
1036 }
1037 }
1038 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
1039 if (socktype && STREQ(sock->idname, socktype->idname)) {
1040 node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
1041 }
1042 }
1043 }
1044
1045 /* initialize tree sockets */
1046 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
1047 if (socktype && STREQ(sock->idname, socktype->idname)) {
1048 node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
1049 }
1050 }
1051 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
1052 if (socktype && STREQ(sock->idname, socktype->idname)) {
1053 node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
1054 }
1055 }
1056 }
1057 FOREACH_NODETREE_END;
1058 }
1059
1060 /* Try to initialize all typeinfo in a node tree.
1061 * NB: In general undefined typeinfo is a perfectly valid case,
1062 * the type may just be registered later.
1063 * In that case the update_typeinfo function will set typeinfo on registration
1064 * and do necessary updates.
1065 */
ntreeSetTypes(const struct bContext * C,bNodeTree * ntree)1066 void ntreeSetTypes(const struct bContext *C, bNodeTree *ntree)
1067 {
1068 ntree->init |= NTREE_TYPE_INIT;
1069
1070 ntree_set_typeinfo(ntree, ntreeTypeFind(ntree->idname));
1071
1072 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1073 node_set_typeinfo(C, ntree, node, nodeTypeFind(node->idname));
1074
1075 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
1076 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
1077 }
1078 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
1079 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
1080 }
1081 }
1082
1083 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
1084 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
1085 }
1086 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
1087 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
1088 }
1089 }
1090
1091 static GHash *nodetreetypes_hash = NULL;
1092 static GHash *nodetypes_hash = NULL;
1093 static GHash *nodesockettypes_hash = NULL;
1094
ntreeTypeFind(const char * idname)1095 bNodeTreeType *ntreeTypeFind(const char *idname)
1096 {
1097 bNodeTreeType *nt;
1098
1099 if (idname[0]) {
1100 nt = BLI_ghash_lookup(nodetreetypes_hash, idname);
1101 if (nt) {
1102 return nt;
1103 }
1104 }
1105
1106 return NULL;
1107 }
1108
ntreeTypeAdd(bNodeTreeType * nt)1109 void ntreeTypeAdd(bNodeTreeType *nt)
1110 {
1111 BLI_ghash_insert(nodetreetypes_hash, nt->idname, nt);
1112 /* XXX pass Main to register function? */
1113 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1114 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1115 update_typeinfo(G_MAIN, NULL, nt, NULL, NULL, false);
1116 }
1117
1118 /* callback for hash value free function */
ntree_free_type(void * treetype_v)1119 static void ntree_free_type(void *treetype_v)
1120 {
1121 bNodeTreeType *treetype = treetype_v;
1122 /* XXX pass Main to unregister function? */
1123 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1124 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1125 update_typeinfo(G_MAIN, NULL, treetype, NULL, NULL, true);
1126 MEM_freeN(treetype);
1127 }
1128
ntreeTypeFreeLink(const bNodeTreeType * nt)1129 void ntreeTypeFreeLink(const bNodeTreeType *nt)
1130 {
1131 BLI_ghash_remove(nodetreetypes_hash, nt->idname, NULL, ntree_free_type);
1132 }
1133
ntreeIsRegistered(bNodeTree * ntree)1134 bool ntreeIsRegistered(bNodeTree *ntree)
1135 {
1136 return (ntree->typeinfo != &NodeTreeTypeUndefined);
1137 }
1138
ntreeTypeGetIterator(void)1139 GHashIterator *ntreeTypeGetIterator(void)
1140 {
1141 return BLI_ghashIterator_new(nodetreetypes_hash);
1142 }
1143
nodeTypeFind(const char * idname)1144 bNodeType *nodeTypeFind(const char *idname)
1145 {
1146 if (idname[0]) {
1147 bNodeType *nt = BLI_ghash_lookup(nodetypes_hash, idname);
1148 if (nt) {
1149 return nt;
1150 }
1151 }
1152
1153 return NULL;
1154 }
1155
free_dynamic_typeinfo(bNodeType * ntype)1156 static void free_dynamic_typeinfo(bNodeType *ntype)
1157 {
1158 if (ntype->type == NODE_DYNAMIC) {
1159 if (ntype->inputs) {
1160 MEM_freeN(ntype->inputs);
1161 }
1162 if (ntype->outputs) {
1163 MEM_freeN(ntype->outputs);
1164 }
1165 }
1166 }
1167
1168 /* callback for hash value free function */
node_free_type(void * nodetype_v)1169 static void node_free_type(void *nodetype_v)
1170 {
1171 bNodeType *nodetype = nodetype_v;
1172 /* XXX pass Main to unregister function? */
1173 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1174 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1175 update_typeinfo(G_MAIN, NULL, NULL, nodetype, NULL, true);
1176
1177 /* XXX deprecated */
1178 if (nodetype->type == NODE_DYNAMIC) {
1179 free_dynamic_typeinfo(nodetype);
1180 }
1181
1182 /* Can be NULL when the type is not dynamically allocated. */
1183 if (nodetype->free_self) {
1184 nodetype->free_self(nodetype);
1185 }
1186 }
1187
nodeRegisterType(bNodeType * nt)1188 void nodeRegisterType(bNodeType *nt)
1189 {
1190 /* debug only: basic verification of registered types */
1191 BLI_assert(nt->idname[0] != '\0');
1192 BLI_assert(nt->poll != NULL);
1193
1194 BLI_ghash_insert(nodetypes_hash, nt->idname, nt);
1195 /* XXX pass Main to register function? */
1196 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1197 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1198 update_typeinfo(G_MAIN, NULL, NULL, nt, NULL, false);
1199 }
1200
nodeUnregisterType(bNodeType * nt)1201 void nodeUnregisterType(bNodeType *nt)
1202 {
1203 BLI_ghash_remove(nodetypes_hash, nt->idname, NULL, node_free_type);
1204 }
1205
nodeIsRegistered(bNode * node)1206 bool nodeIsRegistered(bNode *node)
1207 {
1208 return (node->typeinfo != &NodeTypeUndefined);
1209 }
1210
nodeTypeGetIterator(void)1211 GHashIterator *nodeTypeGetIterator(void)
1212 {
1213 return BLI_ghashIterator_new(nodetypes_hash);
1214 }
1215
nodeSocketTypeFind(const char * idname)1216 bNodeSocketType *nodeSocketTypeFind(const char *idname)
1217 {
1218 if (idname[0]) {
1219 bNodeSocketType *st = BLI_ghash_lookup(nodesockettypes_hash, idname);
1220 if (st) {
1221 return st;
1222 }
1223 }
1224
1225 return NULL;
1226 }
1227
1228 /* callback for hash value free function */
node_free_socket_type(void * socktype_v)1229 static void node_free_socket_type(void *socktype_v)
1230 {
1231 bNodeSocketType *socktype = socktype_v;
1232 /* XXX pass Main to unregister function? */
1233 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1234 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1235 update_typeinfo(G_MAIN, NULL, NULL, NULL, socktype, true);
1236
1237 socktype->free_self(socktype);
1238 }
1239
nodeRegisterSocketType(bNodeSocketType * st)1240 void nodeRegisterSocketType(bNodeSocketType *st)
1241 {
1242 BLI_ghash_insert(nodesockettypes_hash, (void *)st->idname, st);
1243 /* XXX pass Main to register function? */
1244 /* Probably not. It is pretty much expected we want to update G_MAIN here I think -
1245 * or we'd want to update *all* active Mains, which we cannot do anyway currently. */
1246 update_typeinfo(G_MAIN, NULL, NULL, NULL, st, false);
1247 }
1248
nodeUnregisterSocketType(bNodeSocketType * st)1249 void nodeUnregisterSocketType(bNodeSocketType *st)
1250 {
1251 BLI_ghash_remove(nodesockettypes_hash, st->idname, NULL, node_free_socket_type);
1252 }
1253
nodeSocketIsRegistered(bNodeSocket * sock)1254 bool nodeSocketIsRegistered(bNodeSocket *sock)
1255 {
1256 return (sock->typeinfo != &NodeSocketTypeUndefined);
1257 }
1258
nodeSocketTypeGetIterator(void)1259 GHashIterator *nodeSocketTypeGetIterator(void)
1260 {
1261 return BLI_ghashIterator_new(nodesockettypes_hash);
1262 }
1263
nodeFindSocket(const bNode * node,int in_out,const char * identifier)1264 struct bNodeSocket *nodeFindSocket(const bNode *node, int in_out, const char *identifier)
1265 {
1266 const ListBase *sockets = (in_out == SOCK_IN) ? &node->inputs : &node->outputs;
1267 LISTBASE_FOREACH (bNodeSocket *, sock, sockets) {
1268 if (STREQ(sock->identifier, identifier)) {
1269 return sock;
1270 }
1271 }
1272 return NULL;
1273 }
1274
1275 /* find unique socket identifier */
unique_identifier_check(void * arg,const char * identifier)1276 static bool unique_identifier_check(void *arg, const char *identifier)
1277 {
1278 struct ListBase *lb = arg;
1279 LISTBASE_FOREACH (bNodeSocket *, sock, lb) {
1280 if (STREQ(sock->identifier, identifier)) {
1281 return true;
1282 }
1283 }
1284 return false;
1285 }
1286
make_socket(bNodeTree * ntree,bNode * UNUSED (node),int in_out,ListBase * lb,const char * idname,const char * identifier,const char * name)1287 static bNodeSocket *make_socket(bNodeTree *ntree,
1288 bNode *UNUSED(node),
1289 int in_out,
1290 ListBase *lb,
1291 const char *idname,
1292 const char *identifier,
1293 const char *name)
1294 {
1295 char auto_identifier[MAX_NAME];
1296
1297 if (identifier && identifier[0] != '\0') {
1298 /* use explicit identifier */
1299 BLI_strncpy(auto_identifier, identifier, sizeof(auto_identifier));
1300 }
1301 else {
1302 /* if no explicit identifier is given, assign a unique identifier based on the name */
1303 BLI_strncpy(auto_identifier, name, sizeof(auto_identifier));
1304 }
1305 /* make the identifier unique */
1306 BLI_uniquename_cb(
1307 unique_identifier_check, lb, "socket", '.', auto_identifier, sizeof(auto_identifier));
1308
1309 bNodeSocket *sock = MEM_callocN(sizeof(bNodeSocket), "sock");
1310 sock->in_out = in_out;
1311
1312 BLI_strncpy(sock->identifier, auto_identifier, NODE_MAXSTR);
1313 sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
1314
1315 BLI_strncpy(sock->name, name, NODE_MAXSTR);
1316 sock->storage = NULL;
1317 sock->flag |= SOCK_COLLAPSED;
1318 sock->type = SOCK_CUSTOM; /* int type undefined by default */
1319
1320 BLI_strncpy(sock->idname, idname, sizeof(sock->idname));
1321 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(idname));
1322
1323 return sock;
1324 }
1325
socket_id_user_increment(bNodeSocket * sock)1326 static void socket_id_user_increment(bNodeSocket *sock)
1327 {
1328 switch ((eNodeSocketDatatype)sock->type) {
1329 case SOCK_OBJECT: {
1330 bNodeSocketValueObject *default_value = sock->default_value;
1331 id_us_plus((ID *)default_value->value);
1332 break;
1333 }
1334 case SOCK_IMAGE: {
1335 bNodeSocketValueImage *default_value = sock->default_value;
1336 id_us_plus((ID *)default_value->value);
1337 break;
1338 }
1339 case SOCK_FLOAT:
1340 case SOCK_VECTOR:
1341 case SOCK_RGBA:
1342 case SOCK_BOOLEAN:
1343 case SOCK_INT:
1344 case SOCK_STRING:
1345 case __SOCK_MESH:
1346 case SOCK_CUSTOM:
1347 case SOCK_SHADER:
1348 break;
1349 }
1350 }
1351
socket_id_user_decrement(bNodeSocket * sock)1352 static void socket_id_user_decrement(bNodeSocket *sock)
1353 {
1354 switch ((eNodeSocketDatatype)sock->type) {
1355 case SOCK_OBJECT: {
1356 bNodeSocketValueObject *default_value = sock->default_value;
1357 id_us_min(&default_value->value->id);
1358 break;
1359 }
1360 case SOCK_IMAGE: {
1361 bNodeSocketValueImage *default_value = sock->default_value;
1362 id_us_min(&default_value->value->id);
1363 break;
1364 }
1365 case SOCK_FLOAT:
1366 case SOCK_VECTOR:
1367 case SOCK_RGBA:
1368 case SOCK_BOOLEAN:
1369 case SOCK_INT:
1370 case SOCK_STRING:
1371 case __SOCK_MESH:
1372 case SOCK_CUSTOM:
1373 case SOCK_SHADER:
1374 break;
1375 }
1376 }
1377
nodeModifySocketType(bNodeTree * ntree,bNode * UNUSED (node),bNodeSocket * sock,int type,int subtype)1378 void nodeModifySocketType(
1379 bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, int type, int subtype)
1380 {
1381 const char *idname = nodeStaticSocketType(type, subtype);
1382
1383 if (!idname) {
1384 CLOG_ERROR(&LOG, "static node socket type %d undefined", type);
1385 return;
1386 }
1387
1388 if (sock->default_value) {
1389 socket_id_user_decrement(sock);
1390 MEM_freeN(sock->default_value);
1391 sock->default_value = NULL;
1392 }
1393
1394 sock->type = type;
1395 BLI_strncpy(sock->idname, idname, sizeof(sock->idname));
1396 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(idname));
1397 }
1398
nodeAddSocket(bNodeTree * ntree,bNode * node,int in_out,const char * idname,const char * identifier,const char * name)1399 bNodeSocket *nodeAddSocket(bNodeTree *ntree,
1400 bNode *node,
1401 int in_out,
1402 const char *idname,
1403 const char *identifier,
1404 const char *name)
1405 {
1406 BLI_assert(node->type != NODE_FRAME);
1407 BLI_assert(!(in_out == SOCK_IN && node->type == NODE_GROUP_INPUT));
1408 BLI_assert(!(in_out == SOCK_OUT && node->type == NODE_GROUP_OUTPUT));
1409
1410 ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs);
1411 bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name);
1412
1413 BLI_remlink(lb, sock); /* does nothing for new socket */
1414 BLI_addtail(lb, sock);
1415
1416 node->update |= NODE_UPDATE;
1417
1418 return sock;
1419 }
1420
nodeInsertSocket(bNodeTree * ntree,bNode * node,int in_out,const char * idname,bNodeSocket * next_sock,const char * identifier,const char * name)1421 bNodeSocket *nodeInsertSocket(bNodeTree *ntree,
1422 bNode *node,
1423 int in_out,
1424 const char *idname,
1425 bNodeSocket *next_sock,
1426 const char *identifier,
1427 const char *name)
1428 {
1429 ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs);
1430 bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name);
1431
1432 BLI_remlink(lb, sock); /* does nothing for new socket */
1433 BLI_insertlinkbefore(lb, next_sock, sock);
1434
1435 node->update |= NODE_UPDATE;
1436
1437 return sock;
1438 }
1439
nodeStaticSocketType(int type,int subtype)1440 const char *nodeStaticSocketType(int type, int subtype)
1441 {
1442 switch (type) {
1443 case SOCK_FLOAT:
1444 switch (subtype) {
1445 case PROP_UNSIGNED:
1446 return "NodeSocketFloatUnsigned";
1447 case PROP_PERCENTAGE:
1448 return "NodeSocketFloatPercentage";
1449 case PROP_FACTOR:
1450 return "NodeSocketFloatFactor";
1451 case PROP_ANGLE:
1452 return "NodeSocketFloatAngle";
1453 case PROP_TIME:
1454 return "NodeSocketFloatTime";
1455 case PROP_NONE:
1456 default:
1457 return "NodeSocketFloat";
1458 }
1459 case SOCK_INT:
1460 switch (subtype) {
1461 case PROP_UNSIGNED:
1462 return "NodeSocketIntUnsigned";
1463 case PROP_PERCENTAGE:
1464 return "NodeSocketIntPercentage";
1465 case PROP_FACTOR:
1466 return "NodeSocketIntFactor";
1467 case PROP_NONE:
1468 default:
1469 return "NodeSocketInt";
1470 }
1471 case SOCK_BOOLEAN:
1472 return "NodeSocketBool";
1473 case SOCK_VECTOR:
1474 switch (subtype) {
1475 case PROP_TRANSLATION:
1476 return "NodeSocketVectorTranslation";
1477 case PROP_DIRECTION:
1478 return "NodeSocketVectorDirection";
1479 case PROP_VELOCITY:
1480 return "NodeSocketVectorVelocity";
1481 case PROP_ACCELERATION:
1482 return "NodeSocketVectorAcceleration";
1483 case PROP_EULER:
1484 return "NodeSocketVectorEuler";
1485 case PROP_XYZ:
1486 return "NodeSocketVectorXYZ";
1487 case PROP_NONE:
1488 default:
1489 return "NodeSocketVector";
1490 }
1491 case SOCK_RGBA:
1492 return "NodeSocketColor";
1493 case SOCK_STRING:
1494 return "NodeSocketString";
1495 case SOCK_SHADER:
1496 return "NodeSocketShader";
1497 case SOCK_OBJECT:
1498 return "NodeSocketObject";
1499 case SOCK_IMAGE:
1500 return "NodeSocketImage";
1501 }
1502 return NULL;
1503 }
1504
nodeStaticSocketInterfaceType(int type,int subtype)1505 const char *nodeStaticSocketInterfaceType(int type, int subtype)
1506 {
1507 switch (type) {
1508 case SOCK_FLOAT:
1509 switch (subtype) {
1510 case PROP_UNSIGNED:
1511 return "NodeSocketInterfaceFloatUnsigned";
1512 case PROP_PERCENTAGE:
1513 return "NodeSocketInterfaceFloatPercentage";
1514 case PROP_FACTOR:
1515 return "NodeSocketInterfaceFloatFactor";
1516 case PROP_ANGLE:
1517 return "NodeSocketInterfaceFloatAngle";
1518 case PROP_TIME:
1519 return "NodeSocketInterfaceFloatTime";
1520 case PROP_NONE:
1521 default:
1522 return "NodeSocketInterfaceFloat";
1523 }
1524 case SOCK_INT:
1525 switch (subtype) {
1526 case PROP_UNSIGNED:
1527 return "NodeSocketInterfaceIntUnsigned";
1528 case PROP_PERCENTAGE:
1529 return "NodeSocketInterfaceIntPercentage";
1530 case PROP_FACTOR:
1531 return "NodeSocketInterfaceIntFactor";
1532 case PROP_NONE:
1533 default:
1534 return "NodeSocketInterfaceInt";
1535 }
1536 case SOCK_BOOLEAN:
1537 return "NodeSocketInterfaceBool";
1538 case SOCK_VECTOR:
1539 switch (subtype) {
1540 case PROP_TRANSLATION:
1541 return "NodeSocketInterfaceVectorTranslation";
1542 case PROP_DIRECTION:
1543 return "NodeSocketInterfaceVectorDirection";
1544 case PROP_VELOCITY:
1545 return "NodeSocketInterfaceVectorVelocity";
1546 case PROP_ACCELERATION:
1547 return "NodeSocketInterfaceVectorAcceleration";
1548 case PROP_EULER:
1549 return "NodeSocketInterfaceVectorEuler";
1550 case PROP_XYZ:
1551 return "NodeSocketInterfaceVectorXYZ";
1552 case PROP_NONE:
1553 default:
1554 return "NodeSocketInterfaceVector";
1555 }
1556 case SOCK_RGBA:
1557 return "NodeSocketInterfaceColor";
1558 case SOCK_STRING:
1559 return "NodeSocketInterfaceString";
1560 case SOCK_SHADER:
1561 return "NodeSocketInterfaceShader";
1562 case SOCK_OBJECT:
1563 return "NodeSocketInterfaceObject";
1564 case SOCK_IMAGE:
1565 return "NodeSocketInterfaceImage";
1566 }
1567 return NULL;
1568 }
1569
nodeAddStaticSocket(bNodeTree * ntree,bNode * node,int in_out,int type,int subtype,const char * identifier,const char * name)1570 bNodeSocket *nodeAddStaticSocket(bNodeTree *ntree,
1571 bNode *node,
1572 int in_out,
1573 int type,
1574 int subtype,
1575 const char *identifier,
1576 const char *name)
1577 {
1578 const char *idname = nodeStaticSocketType(type, subtype);
1579
1580 if (!idname) {
1581 CLOG_ERROR(&LOG, "static node socket type %d undefined", type);
1582 return NULL;
1583 }
1584
1585 bNodeSocket *sock = nodeAddSocket(ntree, node, in_out, idname, identifier, name);
1586 sock->type = type;
1587 return sock;
1588 }
1589
nodeInsertStaticSocket(bNodeTree * ntree,bNode * node,int in_out,int type,int subtype,bNodeSocket * next_sock,const char * identifier,const char * name)1590 bNodeSocket *nodeInsertStaticSocket(bNodeTree *ntree,
1591 bNode *node,
1592 int in_out,
1593 int type,
1594 int subtype,
1595 bNodeSocket *next_sock,
1596 const char *identifier,
1597 const char *name)
1598 {
1599 const char *idname = nodeStaticSocketType(type, subtype);
1600
1601 if (!idname) {
1602 CLOG_ERROR(&LOG, "static node socket type %d undefined", type);
1603 return NULL;
1604 }
1605
1606 bNodeSocket *sock = nodeInsertSocket(ntree, node, in_out, idname, next_sock, identifier, name);
1607 sock->type = type;
1608 return sock;
1609 }
1610
node_socket_free(bNodeTree * UNUSED (ntree),bNodeSocket * sock,bNode * UNUSED (node),const bool do_id_user)1611 static void node_socket_free(bNodeTree *UNUSED(ntree),
1612 bNodeSocket *sock,
1613 bNode *UNUSED(node),
1614 const bool do_id_user)
1615 {
1616 if (sock->prop) {
1617 IDP_FreePropertyContent_ex(sock->prop, do_id_user);
1618 MEM_freeN(sock->prop);
1619 }
1620
1621 if (sock->default_value) {
1622 if (do_id_user) {
1623 socket_id_user_decrement(sock);
1624 }
1625 MEM_freeN(sock->default_value);
1626 }
1627 }
1628
nodeRemoveSocket(bNodeTree * ntree,bNode * node,bNodeSocket * sock)1629 void nodeRemoveSocket(bNodeTree *ntree, bNode *node, bNodeSocket *sock)
1630 {
1631 LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
1632 if (link->fromsock == sock || link->tosock == sock) {
1633 nodeRemLink(ntree, link);
1634 }
1635 }
1636
1637 /* this is fast, this way we don't need an in_out argument */
1638 BLI_remlink(&node->inputs, sock);
1639 BLI_remlink(&node->outputs, sock);
1640
1641 node_socket_free(ntree, sock, node, true);
1642 MEM_freeN(sock);
1643
1644 node->update |= NODE_UPDATE;
1645 }
1646
nodeRemoveAllSockets(bNodeTree * ntree,bNode * node)1647 void nodeRemoveAllSockets(bNodeTree *ntree, bNode *node)
1648 {
1649 LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
1650 if (link->fromnode == node || link->tonode == node) {
1651 nodeRemLink(ntree, link);
1652 }
1653 }
1654
1655 LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->inputs) {
1656 node_socket_free(ntree, sock, node, true);
1657 MEM_freeN(sock);
1658 }
1659 BLI_listbase_clear(&node->inputs);
1660
1661 LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->outputs) {
1662 node_socket_free(ntree, sock, node, true);
1663 MEM_freeN(sock);
1664 }
1665 BLI_listbase_clear(&node->outputs);
1666
1667 node->update |= NODE_UPDATE;
1668 }
1669
1670 /* finds a node based on its name */
nodeFindNodebyName(bNodeTree * ntree,const char * name)1671 bNode *nodeFindNodebyName(bNodeTree *ntree, const char *name)
1672 {
1673 return BLI_findstring(&ntree->nodes, name, offsetof(bNode, name));
1674 }
1675
1676 /* Finds a node based on given socket and returns true on success. */
nodeFindNode(bNodeTree * ntree,bNodeSocket * sock,bNode ** r_node,int * r_sockindex)1677 bool nodeFindNode(bNodeTree *ntree, bNodeSocket *sock, bNode **r_node, int *r_sockindex)
1678 {
1679 *r_node = NULL;
1680
1681 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1682 ListBase *sockets = (sock->in_out == SOCK_IN) ? &node->inputs : &node->outputs;
1683 int index = 0;
1684 LISTBASE_FOREACH (bNodeSocket *, tsock, sockets) {
1685 if (sock == tsock) {
1686 if (r_node != NULL) {
1687 *r_node = node;
1688 }
1689 if (r_sockindex != NULL) {
1690 *r_sockindex = index;
1691 }
1692 return true;
1693 }
1694 index++;
1695 }
1696 }
1697 return false;
1698 }
1699
1700 /**
1701 * \note Recursive
1702 */
nodeFindRootParent(bNode * node)1703 bNode *nodeFindRootParent(bNode *node)
1704 {
1705 if (node->parent) {
1706 return nodeFindRootParent(node->parent);
1707 }
1708 return node->type == NODE_FRAME ? node : NULL;
1709 }
1710
1711 /**
1712 * \returns true if \a child has \a parent as a parent/grandparent/...
1713 * \note Recursive
1714 */
nodeIsChildOf(const bNode * parent,const bNode * child)1715 bool nodeIsChildOf(const bNode *parent, const bNode *child)
1716 {
1717 if (parent == child) {
1718 return true;
1719 }
1720 if (child->parent) {
1721 return nodeIsChildOf(parent, child->parent);
1722 }
1723 return false;
1724 }
1725
1726 /**
1727 * Iterate over a chain of nodes, starting with \a node_start, executing
1728 * \a callback for each node (which can return false to end iterator).
1729 *
1730 * \param reversed: for backwards iteration
1731 * \note Recursive
1732 */
nodeChainIter(const bNodeTree * ntree,const bNode * node_start,bool (* callback)(bNode *,bNode *,void *,const bool),void * userdata,const bool reversed)1733 void nodeChainIter(const bNodeTree *ntree,
1734 const bNode *node_start,
1735 bool (*callback)(bNode *, bNode *, void *, const bool),
1736 void *userdata,
1737 const bool reversed)
1738 {
1739 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
1740 if ((link->flag & NODE_LINK_VALID) == 0) {
1741 /* Skip links marked as cyclic. */
1742 continue;
1743 }
1744 if (link->tonode && link->fromnode) {
1745 /* Is the link part of the chain meaning node_start == fromnode
1746 * (or tonode for reversed case)? */
1747 if ((reversed && (link->tonode == node_start)) ||
1748 (!reversed && link->fromnode == node_start)) {
1749 if (!callback(link->fromnode, link->tonode, userdata, reversed)) {
1750 return;
1751 }
1752 nodeChainIter(
1753 ntree, reversed ? link->fromnode : link->tonode, callback, userdata, reversed);
1754 }
1755 }
1756 }
1757 }
1758
iter_backwards_ex(const bNodeTree * ntree,const bNode * node_start,bool (* callback)(bNode *,bNode *,void *),void * userdata,char recursion_mask)1759 static void iter_backwards_ex(const bNodeTree *ntree,
1760 const bNode *node_start,
1761 bool (*callback)(bNode *, bNode *, void *),
1762 void *userdata,
1763 char recursion_mask)
1764 {
1765 LISTBASE_FOREACH (bNodeSocket *, sock, &node_start->inputs) {
1766 bNodeLink *link = sock->link;
1767 if (link == NULL) {
1768 continue;
1769 }
1770 if ((link->flag & NODE_LINK_VALID) == 0) {
1771 /* Skip links marked as cyclic. */
1772 continue;
1773 }
1774 if (link->fromnode->iter_flag & recursion_mask) {
1775 continue;
1776 }
1777
1778 link->fromnode->iter_flag |= recursion_mask;
1779
1780 if (!callback(link->fromnode, link->tonode, userdata)) {
1781 return;
1782 }
1783 iter_backwards_ex(ntree, link->fromnode, callback, userdata, recursion_mask);
1784 }
1785 }
1786
1787 /**
1788 * Iterate over a chain of nodes, starting with \a node_start, executing
1789 * \a callback for each node (which can return false to end iterator).
1790 *
1791 * Faster than nodeChainIter. Iter only once per node.
1792 * Can be called recursively (using another nodeChainIterBackwards) by
1793 * setting the recursion_lvl accordingly.
1794 *
1795 * \note Needs updated socket links (ntreeUpdateTree).
1796 * \note Recursive
1797 */
nodeChainIterBackwards(const bNodeTree * ntree,const bNode * node_start,bool (* callback)(bNode *,bNode *,void *),void * userdata,int recursion_lvl)1798 void nodeChainIterBackwards(const bNodeTree *ntree,
1799 const bNode *node_start,
1800 bool (*callback)(bNode *, bNode *, void *),
1801 void *userdata,
1802 int recursion_lvl)
1803 {
1804 if (!node_start) {
1805 return;
1806 }
1807
1808 /* Limited by iter_flag type. */
1809 BLI_assert(recursion_lvl < 8);
1810 char recursion_mask = (1 << recursion_lvl);
1811
1812 /* Reset flag. */
1813 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1814 node->iter_flag &= ~recursion_mask;
1815 }
1816
1817 iter_backwards_ex(ntree, node_start, callback, userdata, recursion_mask);
1818 }
1819
1820 /**
1821 * Iterate over all parents of \a node, executing \a callback for each parent
1822 * (which can return false to end iterator)
1823 *
1824 * \note Recursive
1825 */
nodeParentsIter(bNode * node,bool (* callback)(bNode *,void *),void * userdata)1826 void nodeParentsIter(bNode *node, bool (*callback)(bNode *, void *), void *userdata)
1827 {
1828 if (node->parent) {
1829 if (!callback(node->parent, userdata)) {
1830 return;
1831 }
1832 nodeParentsIter(node->parent, callback, userdata);
1833 }
1834 }
1835
1836 /* ************** Add stuff ********** */
1837
1838 /* Find the first available, non-duplicate name for a given node */
nodeUniqueName(bNodeTree * ntree,bNode * node)1839 void nodeUniqueName(bNodeTree *ntree, bNode *node)
1840 {
1841 BLI_uniquename(
1842 &ntree->nodes, node, DATA_("Node"), '.', offsetof(bNode, name), sizeof(node->name));
1843 }
1844
nodeAddNode(const struct bContext * C,bNodeTree * ntree,const char * idname)1845 bNode *nodeAddNode(const struct bContext *C, bNodeTree *ntree, const char *idname)
1846 {
1847 bNode *node = MEM_callocN(sizeof(bNode), "new node");
1848 BLI_addtail(&ntree->nodes, node);
1849
1850 BLI_strncpy(node->idname, idname, sizeof(node->idname));
1851 node_set_typeinfo(C, ntree, node, nodeTypeFind(idname));
1852
1853 ntree->update |= NTREE_UPDATE_NODES;
1854
1855 return node;
1856 }
1857
nodeAddStaticNode(const struct bContext * C,bNodeTree * ntree,int type)1858 bNode *nodeAddStaticNode(const struct bContext *C, bNodeTree *ntree, int type)
1859 {
1860 const char *idname = NULL;
1861
1862 NODE_TYPES_BEGIN (ntype) {
1863 /* do an extra poll here, because some int types are used
1864 * for multiple node types, this helps find the desired type
1865 */
1866 if (ntype->type == type && (!ntype->poll || ntype->poll(ntype, ntree))) {
1867 idname = ntype->idname;
1868 break;
1869 }
1870 }
1871 NODE_TYPES_END;
1872 if (!idname) {
1873 CLOG_ERROR(&LOG, "static node type %d undefined", type);
1874 return NULL;
1875 }
1876 return nodeAddNode(C, ntree, idname);
1877 }
1878
node_socket_copy(bNodeSocket * sock_dst,const bNodeSocket * sock_src,const int flag)1879 static void node_socket_copy(bNodeSocket *sock_dst, const bNodeSocket *sock_src, const int flag)
1880 {
1881 if (sock_src->prop) {
1882 sock_dst->prop = IDP_CopyProperty_ex(sock_src->prop, flag);
1883 }
1884
1885 if (sock_src->default_value) {
1886 sock_dst->default_value = MEM_dupallocN(sock_src->default_value);
1887
1888 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1889 socket_id_user_increment(sock_dst);
1890 }
1891 }
1892
1893 sock_dst->stack_index = 0;
1894 /* XXX some compositor node (e.g. image, render layers) still store
1895 * some persistent buffer data here, need to clear this to avoid dangling pointers.
1896 */
1897 sock_dst->cache = NULL;
1898 }
1899
1900 /* keep socket listorder identical, for copying links */
1901 /* ntree is the target tree */
1902 /* unique_name needs to be true. It's only disabled for speed when doing GPUnodetrees. */
BKE_node_copy_ex(bNodeTree * ntree,const bNode * node_src,const int flag,const bool unique_name)1903 bNode *BKE_node_copy_ex(bNodeTree *ntree,
1904 const bNode *node_src,
1905 const int flag,
1906 const bool unique_name)
1907 {
1908 bNode *node_dst = MEM_callocN(sizeof(bNode), "dupli node");
1909 bNodeSocket *sock_dst, *sock_src;
1910 bNodeLink *link_dst, *link_src;
1911
1912 *node_dst = *node_src;
1913 /* can be called for nodes outside a node tree (e.g. clipboard) */
1914 if (ntree) {
1915 if (unique_name) {
1916 nodeUniqueName(ntree, node_dst);
1917 }
1918
1919 BLI_addtail(&ntree->nodes, node_dst);
1920 }
1921
1922 BLI_duplicatelist(&node_dst->inputs, &node_src->inputs);
1923 for (sock_dst = node_dst->inputs.first, sock_src = node_src->inputs.first; sock_dst != NULL;
1924 sock_dst = sock_dst->next, sock_src = sock_src->next) {
1925 node_socket_copy(sock_dst, sock_src, flag);
1926 }
1927
1928 BLI_duplicatelist(&node_dst->outputs, &node_src->outputs);
1929 for (sock_dst = node_dst->outputs.first, sock_src = node_src->outputs.first; sock_dst != NULL;
1930 sock_dst = sock_dst->next, sock_src = sock_src->next) {
1931 node_socket_copy(sock_dst, sock_src, flag);
1932 }
1933
1934 if (node_src->prop) {
1935 node_dst->prop = IDP_CopyProperty_ex(node_src->prop, flag);
1936 }
1937
1938 BLI_duplicatelist(&node_dst->internal_links, &node_src->internal_links);
1939 for (link_dst = node_dst->internal_links.first, link_src = node_src->internal_links.first;
1940 link_dst != NULL;
1941 link_dst = link_dst->next, link_src = link_src->next) {
1942 /* This is a bit annoying to do index lookups in a list, but is likely to be faster than
1943 * trying to create a hash-map. At least for usual nodes, which only have so much sockets
1944 * and internal links. */
1945 const int from_sock_index = BLI_findindex(&node_src->inputs, link_src->fromsock);
1946 const int to_sock_index = BLI_findindex(&node_src->outputs, link_src->tosock);
1947 BLI_assert(from_sock_index != -1);
1948 BLI_assert(to_sock_index != -1);
1949 link_dst->fromnode = node_dst;
1950 link_dst->tonode = node_dst;
1951 link_dst->fromsock = BLI_findlink(&node_dst->inputs, from_sock_index);
1952 link_dst->tosock = BLI_findlink(&node_dst->outputs, to_sock_index);
1953 }
1954
1955 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1956 id_us_plus(node_dst->id);
1957 }
1958
1959 if (node_src->typeinfo->copyfunc) {
1960 node_src->typeinfo->copyfunc(ntree, node_dst, node_src);
1961 }
1962
1963 node_dst->new_node = NULL;
1964
1965 /* Only call copy function when a copy is made for the main database, not
1966 * for cases like the dependency graph and localization. */
1967 if (node_dst->typeinfo->copyfunc_api && !(flag & LIB_ID_CREATE_NO_MAIN)) {
1968 PointerRNA ptr;
1969 RNA_pointer_create((ID *)ntree, &RNA_Node, node_dst, &ptr);
1970
1971 node_dst->typeinfo->copyfunc_api(&ptr, node_src);
1972 }
1973
1974 if (ntree) {
1975 ntree->update |= NTREE_UPDATE_NODES;
1976 }
1977
1978 return node_dst;
1979 }
1980
node_set_new_pointers(bNode * node_src,bNode * new_node)1981 static void node_set_new_pointers(bNode *node_src, bNode *new_node)
1982 {
1983 /* Store mapping to the node itself. */
1984 node_src->new_node = new_node;
1985 /* Store mapping to inputs. */
1986 bNodeSocket *new_input_sock = new_node->inputs.first;
1987 bNodeSocket *input_sock_src = node_src->inputs.first;
1988 while (new_input_sock != NULL) {
1989 input_sock_src->new_sock = new_input_sock;
1990 new_input_sock = new_input_sock->next;
1991 input_sock_src = input_sock_src->next;
1992 }
1993 /* Store mapping to outputs. */
1994 bNodeSocket *new_output_sock = new_node->outputs.first;
1995 bNodeSocket *output_sock_src = node_src->outputs.first;
1996 while (new_output_sock != NULL) {
1997 output_sock_src->new_sock = new_output_sock;
1998 new_output_sock = new_output_sock->next;
1999 output_sock_src = output_sock_src->next;
2000 }
2001 }
2002
BKE_node_copy_store_new_pointers(bNodeTree * ntree,bNode * node_src,const int flag)2003 bNode *BKE_node_copy_store_new_pointers(bNodeTree *ntree, bNode *node_src, const int flag)
2004 {
2005 bNode *new_node = BKE_node_copy_ex(ntree, node_src, flag, true);
2006 node_set_new_pointers(node_src, new_node);
2007 return new_node;
2008 }
2009
ntreeCopyTree_ex_new_pointers(const bNodeTree * ntree,Main * bmain,const bool do_id_user)2010 bNodeTree *ntreeCopyTree_ex_new_pointers(const bNodeTree *ntree,
2011 Main *bmain,
2012 const bool do_id_user)
2013 {
2014 bNodeTree *new_ntree = ntreeCopyTree_ex(ntree, bmain, do_id_user);
2015 bNode *new_node = new_ntree->nodes.first;
2016 bNode *node_src = ntree->nodes.first;
2017 while (new_node != NULL) {
2018 node_set_new_pointers(node_src, new_node);
2019 new_node = new_node->next;
2020 node_src = node_src->next;
2021 }
2022 return new_ntree;
2023 }
2024
2025 /* also used via rna api, so we check for proper input output direction */
nodeAddLink(bNodeTree * ntree,bNode * fromnode,bNodeSocket * fromsock,bNode * tonode,bNodeSocket * tosock)2026 bNodeLink *nodeAddLink(
2027 bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, bNode *tonode, bNodeSocket *tosock)
2028 {
2029 bNodeLink *link = NULL;
2030
2031 /* test valid input */
2032 BLI_assert(fromnode);
2033 BLI_assert(tonode);
2034
2035 if (fromsock->in_out == SOCK_OUT && tosock->in_out == SOCK_IN) {
2036 link = MEM_callocN(sizeof(bNodeLink), "link");
2037 if (ntree) {
2038 BLI_addtail(&ntree->links, link);
2039 }
2040 link->fromnode = fromnode;
2041 link->fromsock = fromsock;
2042 link->tonode = tonode;
2043 link->tosock = tosock;
2044 }
2045 else if (fromsock->in_out == SOCK_IN && tosock->in_out == SOCK_OUT) {
2046 /* OK but flip */
2047 link = MEM_callocN(sizeof(bNodeLink), "link");
2048 if (ntree) {
2049 BLI_addtail(&ntree->links, link);
2050 }
2051 link->fromnode = tonode;
2052 link->fromsock = tosock;
2053 link->tonode = fromnode;
2054 link->tosock = fromsock;
2055 }
2056
2057 if (ntree) {
2058 ntree->update |= NTREE_UPDATE_LINKS;
2059 }
2060
2061 return link;
2062 }
2063
nodeRemLink(bNodeTree * ntree,bNodeLink * link)2064 void nodeRemLink(bNodeTree *ntree, bNodeLink *link)
2065 {
2066 /* can be called for links outside a node tree (e.g. clipboard) */
2067 if (ntree) {
2068 BLI_remlink(&ntree->links, link);
2069 }
2070
2071 if (link->tosock) {
2072 link->tosock->link = NULL;
2073 }
2074 MEM_freeN(link);
2075
2076 if (ntree) {
2077 ntree->update |= NTREE_UPDATE_LINKS;
2078 }
2079 }
2080
nodeRemSocketLinks(bNodeTree * ntree,bNodeSocket * sock)2081 void nodeRemSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
2082 {
2083 bNodeLink *link, *next;
2084
2085 for (link = ntree->links.first; link; link = next) {
2086 next = link->next;
2087 if (link->fromsock == sock || link->tosock == sock) {
2088 nodeRemLink(ntree, link);
2089 }
2090 }
2091
2092 ntree->update |= NTREE_UPDATE_LINKS;
2093 }
2094
nodeLinkIsHidden(bNodeLink * link)2095 bool nodeLinkIsHidden(bNodeLink *link)
2096 {
2097 return nodeSocketIsHidden(link->fromsock) || nodeSocketIsHidden(link->tosock);
2098 }
2099
nodeInternalRelink(bNodeTree * ntree,bNode * node)2100 void nodeInternalRelink(bNodeTree *ntree, bNode *node)
2101 {
2102 /* store link pointers in output sockets, for efficient lookup */
2103 LISTBASE_FOREACH (bNodeLink *, link, &node->internal_links) {
2104 link->tosock->link = link;
2105 }
2106
2107 /* redirect downstream links */
2108 LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
2109 /* do we have internal link? */
2110 if (link->fromnode == node) {
2111 if (link->fromsock->link) {
2112 /* get the upstream input link */
2113 bNodeLink *fromlink = link->fromsock->link->fromsock->link;
2114 /* skip the node */
2115 if (fromlink) {
2116 link->fromnode = fromlink->fromnode;
2117 link->fromsock = fromlink->fromsock;
2118
2119 /* if the up- or downstream link is invalid,
2120 * the replacement link will be invalid too.
2121 */
2122 if (!(fromlink->flag & NODE_LINK_VALID)) {
2123 link->flag &= ~NODE_LINK_VALID;
2124 }
2125
2126 ntree->update |= NTREE_UPDATE_LINKS;
2127 }
2128 else {
2129 nodeRemLink(ntree, link);
2130 }
2131 }
2132 else {
2133 nodeRemLink(ntree, link);
2134 }
2135 }
2136 }
2137
2138 /* remove remaining upstream links */
2139 LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
2140 if (link->tonode == node) {
2141 nodeRemLink(ntree, link);
2142 }
2143 }
2144 }
2145
nodeToView(bNode * node,float x,float y,float * rx,float * ry)2146 void nodeToView(bNode *node, float x, float y, float *rx, float *ry)
2147 {
2148 if (node->parent) {
2149 nodeToView(node->parent, x + node->locx, y + node->locy, rx, ry);
2150 }
2151 else {
2152 *rx = x + node->locx;
2153 *ry = y + node->locy;
2154 }
2155 }
2156
nodeFromView(bNode * node,float x,float y,float * rx,float * ry)2157 void nodeFromView(bNode *node, float x, float y, float *rx, float *ry)
2158 {
2159 if (node->parent) {
2160 nodeFromView(node->parent, x, y, rx, ry);
2161 *rx -= node->locx;
2162 *ry -= node->locy;
2163 }
2164 else {
2165 *rx = x - node->locx;
2166 *ry = y - node->locy;
2167 }
2168 }
2169
nodeAttachNodeCheck(bNode * node,bNode * parent)2170 bool nodeAttachNodeCheck(bNode *node, bNode *parent)
2171 {
2172 for (bNode *parent_recurse = node; parent_recurse; parent_recurse = parent_recurse->parent) {
2173 if (parent_recurse == parent) {
2174 return true;
2175 }
2176 }
2177
2178 return false;
2179 }
2180
nodeAttachNode(bNode * node,bNode * parent)2181 void nodeAttachNode(bNode *node, bNode *parent)
2182 {
2183 BLI_assert(parent->type == NODE_FRAME);
2184 BLI_assert(nodeAttachNodeCheck(parent, node) == false);
2185
2186 float locx, locy;
2187 nodeToView(node, 0.0f, 0.0f, &locx, &locy);
2188
2189 node->parent = parent;
2190 /* transform to parent space */
2191 nodeFromView(parent, locx, locy, &node->locx, &node->locy);
2192 }
2193
nodeDetachNode(struct bNode * node)2194 void nodeDetachNode(struct bNode *node)
2195 {
2196 if (node->parent) {
2197 BLI_assert(node->parent->type == NODE_FRAME);
2198
2199 /* transform to view space */
2200 float locx, locy;
2201 nodeToView(node, 0.0f, 0.0f, &locx, &locy);
2202 node->locx = locx;
2203 node->locy = locy;
2204 node->parent = NULL;
2205 }
2206 }
2207
nodePositionRelative(bNode * from_node,bNode * to_node,bNodeSocket * from_sock,bNodeSocket * to_sock)2208 void nodePositionRelative(bNode *from_node,
2209 bNode *to_node,
2210 bNodeSocket *from_sock,
2211 bNodeSocket *to_sock)
2212 {
2213 float offset_x;
2214 int tot_sock_idx;
2215
2216 /* Socket to plug into. */
2217 if (SOCK_IN == to_sock->in_out) {
2218 offset_x = -(from_node->typeinfo->width + 50);
2219 tot_sock_idx = BLI_listbase_count(&to_node->outputs);
2220 tot_sock_idx += BLI_findindex(&to_node->inputs, to_sock);
2221 }
2222 else {
2223 offset_x = to_node->typeinfo->width + 50;
2224 tot_sock_idx = BLI_findindex(&to_node->outputs, to_sock);
2225 }
2226
2227 BLI_assert(tot_sock_idx != -1);
2228
2229 float offset_y = U.widget_unit * tot_sock_idx;
2230
2231 /* Output socket. */
2232 if (from_sock) {
2233 if (SOCK_IN == from_sock->in_out) {
2234 tot_sock_idx = BLI_listbase_count(&from_node->outputs);
2235 tot_sock_idx += BLI_findindex(&from_node->inputs, from_sock);
2236 }
2237 else {
2238 tot_sock_idx = BLI_findindex(&from_node->outputs, from_sock);
2239 }
2240 }
2241
2242 BLI_assert(tot_sock_idx != -1);
2243
2244 offset_y -= U.widget_unit * tot_sock_idx;
2245
2246 from_node->locx = to_node->locx + offset_x;
2247 from_node->locy = to_node->locy - offset_y;
2248 }
2249
nodePositionPropagate(bNode * node)2250 void nodePositionPropagate(bNode *node)
2251 {
2252 LISTBASE_FOREACH (bNodeSocket *, nsock, &node->inputs) {
2253 if (nsock->link != NULL) {
2254 bNodeLink *link = nsock->link;
2255 nodePositionRelative(link->fromnode, link->tonode, link->fromsock, link->tosock);
2256 nodePositionPropagate(link->fromnode);
2257 }
2258 }
2259 }
2260
ntreeAddTree(Main * bmain,const char * name,const char * idname)2261 bNodeTree *ntreeAddTree(Main *bmain, const char *name, const char *idname)
2262 {
2263 bNodeTree *ntree;
2264
2265 /* trees are created as local trees for compositor, material or texture nodes,
2266 * node groups and other tree types are created as library data.
2267 */
2268 if (bmain) {
2269 ntree = BKE_libblock_alloc(bmain, ID_NT, name, 0);
2270 }
2271 else {
2272 ntree = MEM_callocN(sizeof(bNodeTree), "new node tree");
2273 ntree->id.flag |= LIB_EMBEDDED_DATA;
2274 *((short *)ntree->id.name) = ID_NT;
2275 BLI_strncpy(ntree->id.name + 2, name, sizeof(ntree->id.name));
2276 }
2277
2278 /* Types are fully initialized at this point,
2279 * if an undefined node is added later this will be reset.
2280 */
2281 ntree->init |= NTREE_TYPE_INIT;
2282
2283 BLI_strncpy(ntree->idname, idname, sizeof(ntree->idname));
2284 ntree_set_typeinfo(ntree, ntreeTypeFind(idname));
2285
2286 return ntree;
2287 }
2288
ntreeCopyTree_ex(const bNodeTree * ntree,Main * bmain,const bool do_id_user)2289 bNodeTree *ntreeCopyTree_ex(const bNodeTree *ntree, Main *bmain, const bool do_id_user)
2290 {
2291 const int flag = do_id_user ? 0 : LIB_ID_CREATE_NO_USER_REFCOUNT | LIB_ID_CREATE_NO_MAIN;
2292
2293 bNodeTree *ntree_copy = (bNodeTree *)BKE_id_copy_ex(bmain, (ID *)ntree, NULL, flag);
2294 return ntree_copy;
2295 }
ntreeCopyTree(Main * bmain,const bNodeTree * ntree)2296 bNodeTree *ntreeCopyTree(Main *bmain, const bNodeTree *ntree)
2297 {
2298 return ntreeCopyTree_ex(ntree, bmain, true);
2299 }
2300
2301 /* *************** Node Preview *********** */
2302
2303 /* XXX this should be removed eventually ...
2304 * Currently BKE functions are modeled closely on previous code,
2305 * using BKE_node_preview_init_tree to set up previews for a whole node tree in advance.
2306 * This should be left more to the individual node tree implementations.
2307 */
BKE_node_preview_used(bNode * node)2308 int BKE_node_preview_used(bNode *node)
2309 {
2310 /* XXX check for closed nodes? */
2311 return (node->typeinfo->flag & NODE_PREVIEW) != 0;
2312 }
2313
BKE_node_preview_verify(bNodeInstanceHash * previews,bNodeInstanceKey key,int xsize,int ysize,bool create)2314 bNodePreview *BKE_node_preview_verify(
2315 bNodeInstanceHash *previews, bNodeInstanceKey key, int xsize, int ysize, bool create)
2316 {
2317 bNodePreview *preview = BKE_node_instance_hash_lookup(previews, key);
2318 if (!preview) {
2319 if (create) {
2320 preview = MEM_callocN(sizeof(bNodePreview), "node preview");
2321 BKE_node_instance_hash_insert(previews, key, preview);
2322 }
2323 else {
2324 return NULL;
2325 }
2326 }
2327
2328 /* node previews can get added with variable size this way */
2329 if (xsize == 0 || ysize == 0) {
2330 return preview;
2331 }
2332
2333 /* sanity checks & initialize */
2334 if (preview->rect) {
2335 if (preview->xsize != xsize || preview->ysize != ysize) {
2336 MEM_freeN(preview->rect);
2337 preview->rect = NULL;
2338 }
2339 }
2340
2341 if (preview->rect == NULL) {
2342 preview->rect = MEM_callocN(4 * xsize + xsize * ysize * sizeof(char[4]), "node preview rect");
2343 preview->xsize = xsize;
2344 preview->ysize = ysize;
2345 }
2346 /* no clear, makes nicer previews */
2347
2348 return preview;
2349 }
2350
BKE_node_preview_copy(bNodePreview * preview)2351 bNodePreview *BKE_node_preview_copy(bNodePreview *preview)
2352 {
2353 bNodePreview *new_preview = MEM_dupallocN(preview);
2354 if (preview->rect) {
2355 new_preview->rect = MEM_dupallocN(preview->rect);
2356 }
2357 return new_preview;
2358 }
2359
BKE_node_preview_free(bNodePreview * preview)2360 void BKE_node_preview_free(bNodePreview *preview)
2361 {
2362 if (preview->rect) {
2363 MEM_freeN(preview->rect);
2364 }
2365 MEM_freeN(preview);
2366 }
2367
node_preview_init_tree_recursive(bNodeInstanceHash * previews,bNodeTree * ntree,bNodeInstanceKey parent_key,int xsize,int ysize,int create)2368 static void node_preview_init_tree_recursive(bNodeInstanceHash *previews,
2369 bNodeTree *ntree,
2370 bNodeInstanceKey parent_key,
2371 int xsize,
2372 int ysize,
2373 int create)
2374 {
2375 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2376 bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node);
2377
2378 if (BKE_node_preview_used(node)) {
2379 node->preview_xsize = xsize;
2380 node->preview_ysize = ysize;
2381
2382 BKE_node_preview_verify(previews, key, xsize, ysize, create);
2383 }
2384
2385 if (node->type == NODE_GROUP && node->id) {
2386 node_preview_init_tree_recursive(previews, (bNodeTree *)node->id, key, xsize, ysize, create);
2387 }
2388 }
2389 }
2390
BKE_node_preview_init_tree(bNodeTree * ntree,int xsize,int ysize,int create_previews)2391 void BKE_node_preview_init_tree(bNodeTree *ntree, int xsize, int ysize, int create_previews)
2392 {
2393 if (!ntree) {
2394 return;
2395 }
2396
2397 if (!ntree->previews) {
2398 ntree->previews = BKE_node_instance_hash_new("node previews");
2399 }
2400
2401 node_preview_init_tree_recursive(
2402 ntree->previews, ntree, NODE_INSTANCE_KEY_BASE, xsize, ysize, create_previews);
2403 }
2404
node_preview_tag_used_recursive(bNodeInstanceHash * previews,bNodeTree * ntree,bNodeInstanceKey parent_key)2405 static void node_preview_tag_used_recursive(bNodeInstanceHash *previews,
2406 bNodeTree *ntree,
2407 bNodeInstanceKey parent_key)
2408 {
2409 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2410 bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node);
2411
2412 if (BKE_node_preview_used(node)) {
2413 BKE_node_instance_hash_tag_key(previews, key);
2414 }
2415
2416 if (node->type == NODE_GROUP && node->id) {
2417 node_preview_tag_used_recursive(previews, (bNodeTree *)node->id, key);
2418 }
2419 }
2420 }
2421
BKE_node_preview_remove_unused(bNodeTree * ntree)2422 void BKE_node_preview_remove_unused(bNodeTree *ntree)
2423 {
2424 if (!ntree || !ntree->previews) {
2425 return;
2426 }
2427
2428 /* use the instance hash functions for tagging and removing unused previews */
2429 BKE_node_instance_hash_clear_tags(ntree->previews);
2430 node_preview_tag_used_recursive(ntree->previews, ntree, NODE_INSTANCE_KEY_BASE);
2431
2432 BKE_node_instance_hash_remove_untagged(ntree->previews,
2433 (bNodeInstanceValueFP)BKE_node_preview_free);
2434 }
2435
BKE_node_preview_free_tree(bNodeTree * ntree)2436 void BKE_node_preview_free_tree(bNodeTree *ntree)
2437 {
2438 if (!ntree) {
2439 return;
2440 }
2441
2442 if (ntree->previews) {
2443 BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
2444 ntree->previews = NULL;
2445 }
2446 }
2447
BKE_node_preview_clear(bNodePreview * preview)2448 void BKE_node_preview_clear(bNodePreview *preview)
2449 {
2450 if (preview && preview->rect) {
2451 memset(preview->rect, 0, MEM_allocN_len(preview->rect));
2452 }
2453 }
2454
BKE_node_preview_clear_tree(bNodeTree * ntree)2455 void BKE_node_preview_clear_tree(bNodeTree *ntree)
2456 {
2457 if (!ntree || !ntree->previews) {
2458 return;
2459 }
2460
2461 bNodeInstanceHashIterator iter;
2462 NODE_INSTANCE_HASH_ITER (iter, ntree->previews) {
2463 bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
2464 BKE_node_preview_clear(preview);
2465 }
2466 }
2467
node_preview_sync(bNodePreview * to,bNodePreview * from)2468 static void node_preview_sync(bNodePreview *to, bNodePreview *from)
2469 {
2470 /* sizes should have been initialized by BKE_node_preview_init_tree */
2471 BLI_assert(to->xsize == from->xsize && to->ysize == from->ysize);
2472
2473 /* copy over contents of previews */
2474 if (to->rect && from->rect) {
2475 int xsize = to->xsize;
2476 int ysize = to->ysize;
2477 memcpy(to->rect, from->rect, xsize * ysize * sizeof(char[4]));
2478 }
2479 }
2480
BKE_node_preview_sync_tree(bNodeTree * to_ntree,bNodeTree * from_ntree)2481 void BKE_node_preview_sync_tree(bNodeTree *to_ntree, bNodeTree *from_ntree)
2482 {
2483 bNodeInstanceHash *from_previews = from_ntree->previews;
2484 bNodeInstanceHash *to_previews = to_ntree->previews;
2485
2486 if (!from_previews || !to_previews) {
2487 return;
2488 }
2489
2490 bNodeInstanceHashIterator iter;
2491 NODE_INSTANCE_HASH_ITER (iter, from_previews) {
2492 bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
2493 bNodePreview *from = BKE_node_instance_hash_iterator_get_value(&iter);
2494 bNodePreview *to = BKE_node_instance_hash_lookup(to_previews, key);
2495
2496 if (from && to) {
2497 node_preview_sync(to, from);
2498 }
2499 }
2500 }
2501
BKE_node_preview_merge_tree(bNodeTree * to_ntree,bNodeTree * from_ntree,bool remove_old)2502 void BKE_node_preview_merge_tree(bNodeTree *to_ntree, bNodeTree *from_ntree, bool remove_old)
2503 {
2504 if (remove_old || !to_ntree->previews) {
2505 /* free old previews */
2506 if (to_ntree->previews) {
2507 BKE_node_instance_hash_free(to_ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
2508 }
2509
2510 /* transfer previews */
2511 to_ntree->previews = from_ntree->previews;
2512 from_ntree->previews = NULL;
2513
2514 /* clean up, in case any to_ntree nodes have been removed */
2515 BKE_node_preview_remove_unused(to_ntree);
2516 }
2517 else {
2518 if (from_ntree->previews) {
2519 bNodeInstanceHashIterator iter;
2520 NODE_INSTANCE_HASH_ITER (iter, from_ntree->previews) {
2521 bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
2522 bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
2523
2524 /* replace existing previews */
2525 BKE_node_instance_hash_remove(
2526 to_ntree->previews, key, (bNodeInstanceValueFP)BKE_node_preview_free);
2527 BKE_node_instance_hash_insert(to_ntree->previews, key, preview);
2528 }
2529
2530 /* Note: NULL free function here,
2531 * because pointers have already been moved over to to_ntree->previews! */
2532 BKE_node_instance_hash_free(from_ntree->previews, NULL);
2533 from_ntree->previews = NULL;
2534 }
2535 }
2536 }
2537
2538 /* hack warning! this function is only used for shader previews, and
2539 * since it gets called multiple times per pixel for Ztransp we only
2540 * add the color once. Preview gets cleared before it starts render though */
BKE_node_preview_set_pixel(bNodePreview * preview,const float col[4],int x,int y,bool do_manage)2541 void BKE_node_preview_set_pixel(
2542 bNodePreview *preview, const float col[4], int x, int y, bool do_manage)
2543 {
2544 if (preview) {
2545 if (x >= 0 && y >= 0) {
2546 if (x < preview->xsize && y < preview->ysize) {
2547 unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x);
2548
2549 if (do_manage) {
2550 linearrgb_to_srgb_uchar4(tar, col);
2551 }
2552 else {
2553 rgba_float_to_uchar(tar, col);
2554 }
2555 }
2556 // else printf("prv out bound x y %d %d\n", x, y);
2557 }
2558 // else printf("prv out bound x y %d %d\n", x, y);
2559 }
2560 }
2561
2562 /* ************** Free stuff ********** */
2563
2564 /* goes over entire tree */
nodeUnlinkNode(bNodeTree * ntree,bNode * node)2565 void nodeUnlinkNode(bNodeTree *ntree, bNode *node)
2566 {
2567 LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
2568 ListBase *lb;
2569 if (link->fromnode == node) {
2570 lb = &node->outputs;
2571 if (link->tonode) {
2572 link->tonode->update |= NODE_UPDATE;
2573 }
2574 }
2575 else if (link->tonode == node) {
2576 lb = &node->inputs;
2577 }
2578 else {
2579 lb = NULL;
2580 }
2581
2582 if (lb) {
2583 LISTBASE_FOREACH (bNodeSocket *, sock, lb) {
2584 if (link->fromsock == sock || link->tosock == sock) {
2585 nodeRemLink(ntree, link);
2586 break;
2587 }
2588 }
2589 }
2590 }
2591 }
2592
node_unlink_attached(bNodeTree * ntree,bNode * parent)2593 static void node_unlink_attached(bNodeTree *ntree, bNode *parent)
2594 {
2595 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2596 if (node->parent == parent) {
2597 nodeDetachNode(node);
2598 }
2599 }
2600 }
2601
2602 /* Free the node itself. ID user refcounting is up the caller,
2603 * that does not happen here. */
node_free_node(bNodeTree * ntree,bNode * node)2604 static void node_free_node(bNodeTree *ntree, bNode *node)
2605 {
2606 /* since it is called while free database, node->id is undefined */
2607
2608 /* can be called for nodes outside a node tree (e.g. clipboard) */
2609 if (ntree) {
2610 /* remove all references to this node */
2611 nodeUnlinkNode(ntree, node);
2612 node_unlink_attached(ntree, node);
2613
2614 BLI_remlink(&ntree->nodes, node);
2615
2616 if (ntree->typeinfo->free_node_cache) {
2617 ntree->typeinfo->free_node_cache(ntree, node);
2618 }
2619
2620 /* texture node has bad habit of keeping exec data around */
2621 if (ntree->type == NTREE_TEXTURE && ntree->execdata) {
2622 ntreeTexEndExecTree(ntree->execdata);
2623 ntree->execdata = NULL;
2624 }
2625 }
2626
2627 if (node->typeinfo->freefunc) {
2628 node->typeinfo->freefunc(node);
2629 }
2630
2631 LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->inputs) {
2632 /* Remember, no ID user refcount management here! */
2633 node_socket_free(ntree, sock, node, false);
2634 MEM_freeN(sock);
2635 }
2636 LISTBASE_FOREACH_MUTABLE (bNodeSocket *, sock, &node->outputs) {
2637 /* Remember, no ID user refcount management here! */
2638 node_socket_free(ntree, sock, node, false);
2639 MEM_freeN(sock);
2640 }
2641
2642 BLI_freelistN(&node->internal_links);
2643
2644 if (node->prop) {
2645 /* Remember, no ID user refcount management here! */
2646 IDP_FreePropertyContent_ex(node->prop, false);
2647 MEM_freeN(node->prop);
2648 }
2649
2650 MEM_freeN(node);
2651
2652 if (ntree) {
2653 ntree->update |= NTREE_UPDATE_NODES;
2654 }
2655 }
2656
ntreeFreeLocalNode(bNodeTree * ntree,bNode * node)2657 void ntreeFreeLocalNode(bNodeTree *ntree, bNode *node)
2658 {
2659 /* For removing nodes while editing localized node trees. */
2660 BLI_assert((ntree->id.tag & LIB_TAG_LOCALIZED) != 0);
2661 node_free_node(ntree, node);
2662 }
2663
nodeRemoveNode(Main * bmain,bNodeTree * ntree,bNode * node,bool do_id_user)2664 void nodeRemoveNode(Main *bmain, bNodeTree *ntree, bNode *node, bool do_id_user)
2665 {
2666 /* This function is not for localized node trees, we do not want
2667 * do to ID user refcounting and removal of animdation data then. */
2668 BLI_assert((ntree->id.tag & LIB_TAG_LOCALIZED) == 0);
2669
2670 if (do_id_user) {
2671 /* Free callback for NodeCustomGroup. */
2672 if (node->typeinfo->freefunc_api) {
2673 PointerRNA ptr;
2674 RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
2675
2676 node->typeinfo->freefunc_api(&ptr);
2677 }
2678
2679 /* Do user counting. */
2680 if (node->id) {
2681 id_us_min(node->id);
2682 }
2683
2684 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
2685 socket_id_user_decrement(sock);
2686 }
2687 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
2688 socket_id_user_decrement(sock);
2689 }
2690 }
2691
2692 /* Remove animation data. */
2693 char propname_esc[MAX_IDPROP_NAME * 2];
2694 char prefix[MAX_IDPROP_NAME * 2];
2695
2696 BLI_strescape(propname_esc, node->name, sizeof(propname_esc));
2697 BLI_snprintf(prefix, sizeof(prefix), "nodes[\"%s\"]", propname_esc);
2698
2699 if (BKE_animdata_fix_paths_remove((ID *)ntree, prefix)) {
2700 if (bmain != NULL) {
2701 DEG_relations_tag_update(bmain);
2702 }
2703 }
2704
2705 /* Free node itself. */
2706 node_free_node(ntree, node);
2707 }
2708
node_socket_interface_free(bNodeTree * UNUSED (ntree),bNodeSocket * sock,const bool do_id_user)2709 static void node_socket_interface_free(bNodeTree *UNUSED(ntree),
2710 bNodeSocket *sock,
2711 const bool do_id_user)
2712 {
2713 if (sock->prop) {
2714 IDP_FreeProperty_ex(sock->prop, do_id_user);
2715 }
2716
2717 if (sock->default_value) {
2718 if (do_id_user) {
2719 socket_id_user_decrement(sock);
2720 }
2721 MEM_freeN(sock->default_value);
2722 }
2723 }
2724
free_localized_node_groups(bNodeTree * ntree)2725 static void free_localized_node_groups(bNodeTree *ntree)
2726 {
2727 /* Only localized node trees store a copy for each node group tree.
2728 * Each node group tree in a localized node tree can be freed,
2729 * since it is a localized copy itself (no risk of accessing free'd
2730 * data in main, see T37939).
2731 */
2732 if (!(ntree->id.tag & LIB_TAG_LOCALIZED)) {
2733 return;
2734 }
2735
2736 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2737 if ((ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) && node->id) {
2738 bNodeTree *ngroup = (bNodeTree *)node->id;
2739 ntreeFreeTree(ngroup);
2740 MEM_freeN(ngroup);
2741 }
2742 }
2743 }
2744
2745 /* Free (or release) any data used by this nodetree. Does not free the
2746 * nodetree itself and does no ID user counting. */
ntreeFreeTree(bNodeTree * ntree)2747 void ntreeFreeTree(bNodeTree *ntree)
2748 {
2749 ntree_free_data(&ntree->id);
2750 BKE_animdata_free(&ntree->id, false);
2751 }
2752
ntreeFreeEmbeddedTree(bNodeTree * ntree)2753 void ntreeFreeEmbeddedTree(bNodeTree *ntree)
2754 {
2755 ntreeFreeTree(ntree);
2756 BKE_libblock_free_data(&ntree->id, true);
2757 }
2758
ntreeFreeLocalTree(bNodeTree * ntree)2759 void ntreeFreeLocalTree(bNodeTree *ntree)
2760 {
2761 if (ntree->id.tag & LIB_TAG_LOCALIZED) {
2762 ntreeFreeTree(ntree);
2763 }
2764 else {
2765 ntreeFreeTree(ntree);
2766 BKE_libblock_free_data(&ntree->id, true);
2767 }
2768 }
2769
ntreeFreeCache(bNodeTree * ntree)2770 void ntreeFreeCache(bNodeTree *ntree)
2771 {
2772 if (ntree == NULL) {
2773 return;
2774 }
2775
2776 if (ntree->typeinfo->free_cache) {
2777 ntree->typeinfo->free_cache(ntree);
2778 }
2779 }
2780
ntreeSetOutput(bNodeTree * ntree)2781 void ntreeSetOutput(bNodeTree *ntree)
2782 {
2783 /* find the active outputs, might become tree type dependent handler */
2784 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2785 if (node->typeinfo->nclass == NODE_CLASS_OUTPUT) {
2786 /* we need a check for which output node should be tagged like this, below an exception */
2787 if (node->type == CMP_NODE_OUTPUT_FILE) {
2788 continue;
2789 }
2790
2791 int output = 0;
2792 /* there is more types having output class, each one is checked */
2793 LISTBASE_FOREACH (bNode *, tnode, &ntree->nodes) {
2794 if (tnode->typeinfo->nclass == NODE_CLASS_OUTPUT) {
2795 if (ntree->type == NTREE_COMPOSIT) {
2796 /* same type, exception for viewer */
2797 if (tnode->type == node->type ||
2798 (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
2799 ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))) {
2800 if (tnode->flag & NODE_DO_OUTPUT) {
2801 output++;
2802 if (output > 1) {
2803 tnode->flag &= ~NODE_DO_OUTPUT;
2804 }
2805 }
2806 }
2807 }
2808 else {
2809 /* same type */
2810 if (tnode->type == node->type) {
2811 if (tnode->flag & NODE_DO_OUTPUT) {
2812 output++;
2813 if (output > 1) {
2814 tnode->flag &= ~NODE_DO_OUTPUT;
2815 }
2816 }
2817 }
2818 }
2819 }
2820 }
2821 if (output == 0) {
2822 node->flag |= NODE_DO_OUTPUT;
2823 }
2824 }
2825
2826 /* group node outputs use this flag too */
2827 if (node->type == NODE_GROUP_OUTPUT) {
2828 int output = 0;
2829 LISTBASE_FOREACH (bNode *, tnode, &ntree->nodes) {
2830 if (tnode->type == NODE_GROUP_OUTPUT) {
2831 if (tnode->flag & NODE_DO_OUTPUT) {
2832 output++;
2833 if (output > 1) {
2834 tnode->flag &= ~NODE_DO_OUTPUT;
2835 }
2836 }
2837 }
2838 }
2839 if (output == 0) {
2840 node->flag |= NODE_DO_OUTPUT;
2841 }
2842 }
2843 }
2844
2845 /* here we could recursively set which nodes have to be done,
2846 * might be different for editor or for "real" use... */
2847 }
2848
2849 /** Get address of potential nodetree pointer of given ID.
2850 *
2851 * \warning Using this function directly is potentially dangerous, if you don't know or are not
2852 * sure, please use `ntreeFromID()` instead. */
BKE_ntree_ptr_from_id(ID * id)2853 bNodeTree **BKE_ntree_ptr_from_id(ID *id)
2854 {
2855 switch (GS(id->name)) {
2856 case ID_MA:
2857 return &((Material *)id)->nodetree;
2858 case ID_LA:
2859 return &((Light *)id)->nodetree;
2860 case ID_WO:
2861 return &((World *)id)->nodetree;
2862 case ID_TE:
2863 return &((Tex *)id)->nodetree;
2864 case ID_SCE:
2865 return &((Scene *)id)->nodetree;
2866 case ID_LS:
2867 return &((FreestyleLineStyle *)id)->nodetree;
2868 case ID_SIM:
2869 return &((Simulation *)id)->nodetree;
2870 default:
2871 return NULL;
2872 }
2873 }
2874
2875 /* Returns the private NodeTree object of the datablock, if it has one. */
ntreeFromID(ID * id)2876 bNodeTree *ntreeFromID(ID *id)
2877 {
2878 bNodeTree **nodetree = BKE_ntree_ptr_from_id(id);
2879 return (nodetree != NULL) ? *nodetree : NULL;
2880 }
2881
2882 /* Finds and returns the datablock that privately owns the given tree, or NULL. */
BKE_node_tree_find_owner_ID(Main * bmain,struct bNodeTree * ntree)2883 ID *BKE_node_tree_find_owner_ID(Main *bmain, struct bNodeTree *ntree)
2884 {
2885 ListBase *lists[] = {&bmain->materials,
2886 &bmain->lights,
2887 &bmain->worlds,
2888 &bmain->textures,
2889 &bmain->scenes,
2890 &bmain->linestyles,
2891 &bmain->simulations,
2892 NULL};
2893
2894 for (int i = 0; lists[i] != NULL; i++) {
2895 LISTBASE_FOREACH (ID *, id, lists[i]) {
2896 if (ntreeFromID(id) == ntree) {
2897 return id;
2898 }
2899 }
2900 }
2901
2902 return NULL;
2903 }
2904
ntreeNodeExists(bNodeTree * ntree,bNode * testnode)2905 bool ntreeNodeExists(bNodeTree *ntree, bNode *testnode)
2906 {
2907 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2908 if (node == testnode) {
2909 return true;
2910 }
2911 }
2912 return false;
2913 }
2914
ntreeOutputExists(bNode * node,bNodeSocket * testsock)2915 bool ntreeOutputExists(bNode *node, bNodeSocket *testsock)
2916 {
2917 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
2918 if (sock == testsock) {
2919 return true;
2920 }
2921 }
2922 return false;
2923 }
2924
ntreeNodeFlagSet(const bNodeTree * ntree,const int flag,const bool enable)2925 void ntreeNodeFlagSet(const bNodeTree *ntree, const int flag, const bool enable)
2926 {
2927 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
2928 if (enable) {
2929 node->flag |= flag;
2930 }
2931 else {
2932 node->flag &= ~flag;
2933 }
2934 }
2935 }
2936
2937 /* returns localized tree for execution in threads */
ntreeLocalize(bNodeTree * ntree)2938 bNodeTree *ntreeLocalize(bNodeTree *ntree)
2939 {
2940 if (ntree) {
2941 /* Make full copy outside of Main database.
2942 * Note: previews are not copied here.
2943 */
2944 bNodeTree *ltree = (bNodeTree *)BKE_id_copy_ex(
2945 NULL, &ntree->id, NULL, (LIB_ID_COPY_LOCALIZE | LIB_ID_COPY_NO_ANIMDATA));
2946
2947 ltree->id.tag |= LIB_TAG_LOCALIZED;
2948
2949 LISTBASE_FOREACH (bNode *, node, <ree->nodes) {
2950 if ((ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) && node->id) {
2951 node->id = (ID *)ntreeLocalize((bNodeTree *)node->id);
2952 }
2953 }
2954
2955 /* ensures only a single output node is enabled */
2956 ntreeSetOutput(ntree);
2957
2958 bNode *node_src = ntree->nodes.first;
2959 bNode *node_local = ltree->nodes.first;
2960 while (node_src != NULL) {
2961 node_local->original = node_src;
2962 node_src = node_src->next;
2963 node_local = node_local->next;
2964 }
2965
2966 if (ntree->typeinfo->localize) {
2967 ntree->typeinfo->localize(ltree, ntree);
2968 }
2969
2970 return ltree;
2971 }
2972
2973 return NULL;
2974 }
2975
2976 /* sync local composite with real tree */
2977 /* local tree is supposed to be running, be careful moving previews! */
2978 /* is called by jobs manager, outside threads, so it doesn't happen during draw */
ntreeLocalSync(bNodeTree * localtree,bNodeTree * ntree)2979 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
2980 {
2981 if (localtree && ntree) {
2982 if (ntree->typeinfo->local_sync) {
2983 ntree->typeinfo->local_sync(localtree, ntree);
2984 }
2985 }
2986 }
2987
2988 /* merge local tree results back, and free local tree */
2989 /* we have to assume the editor already changed completely */
ntreeLocalMerge(Main * bmain,bNodeTree * localtree,bNodeTree * ntree)2990 void ntreeLocalMerge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
2991 {
2992 if (ntree && localtree) {
2993 if (ntree->typeinfo->local_merge) {
2994 ntree->typeinfo->local_merge(bmain, localtree, ntree);
2995 }
2996
2997 ntreeFreeTree(localtree);
2998 MEM_freeN(localtree);
2999 }
3000 }
3001
3002 /* ************ NODE TREE INTERFACE *************** */
3003
make_socket_interface(bNodeTree * ntree,int in_out,const char * idname,const char * name)3004 static bNodeSocket *make_socket_interface(bNodeTree *ntree,
3005 int in_out,
3006 const char *idname,
3007 const char *name)
3008 {
3009 bNodeSocketType *stype = nodeSocketTypeFind(idname);
3010 int own_index = ntree->cur_index++;
3011
3012 if (stype == NULL) {
3013 return NULL;
3014 }
3015
3016 bNodeSocket *sock = MEM_callocN(sizeof(bNodeSocket), "socket template");
3017 BLI_strncpy(sock->idname, stype->idname, sizeof(sock->idname));
3018 node_socket_set_typeinfo(ntree, sock, stype);
3019 sock->in_out = in_out;
3020 sock->type = SOCK_CUSTOM; /* int type undefined by default */
3021
3022 /* assign new unique index */
3023 own_index = ntree->cur_index++;
3024 /* use the own_index as socket identifier */
3025 if (in_out == SOCK_IN) {
3026 BLI_snprintf(sock->identifier, MAX_NAME, "Input_%d", own_index);
3027 }
3028 else {
3029 BLI_snprintf(sock->identifier, MAX_NAME, "Output_%d", own_index);
3030 }
3031
3032 sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
3033
3034 BLI_strncpy(sock->name, name, NODE_MAXSTR);
3035 sock->storage = NULL;
3036 sock->flag |= SOCK_COLLAPSED;
3037
3038 return sock;
3039 }
3040
ntreeFindSocketInterface(bNodeTree * ntree,int in_out,const char * identifier)3041 bNodeSocket *ntreeFindSocketInterface(bNodeTree *ntree, int in_out, const char *identifier)
3042 {
3043 ListBase *sockets = (in_out == SOCK_IN) ? &ntree->inputs : &ntree->outputs;
3044 LISTBASE_FOREACH (bNodeSocket *, iosock, sockets) {
3045 if (STREQ(iosock->identifier, identifier)) {
3046 return iosock;
3047 }
3048 }
3049 return NULL;
3050 }
3051
ntreeAddSocketInterface(bNodeTree * ntree,int in_out,const char * idname,const char * name)3052 bNodeSocket *ntreeAddSocketInterface(bNodeTree *ntree,
3053 int in_out,
3054 const char *idname,
3055 const char *name)
3056 {
3057 bNodeSocket *iosock = make_socket_interface(ntree, in_out, idname, name);
3058 if (in_out == SOCK_IN) {
3059 BLI_addtail(&ntree->inputs, iosock);
3060 ntree->update |= NTREE_UPDATE_GROUP_IN;
3061 }
3062 else if (in_out == SOCK_OUT) {
3063 BLI_addtail(&ntree->outputs, iosock);
3064 ntree->update |= NTREE_UPDATE_GROUP_OUT;
3065 }
3066 return iosock;
3067 }
3068
ntreeInsertSocketInterface(bNodeTree * ntree,int in_out,const char * idname,bNodeSocket * next_sock,const char * name)3069 bNodeSocket *ntreeInsertSocketInterface(
3070 bNodeTree *ntree, int in_out, const char *idname, bNodeSocket *next_sock, const char *name)
3071 {
3072 bNodeSocket *iosock = make_socket_interface(ntree, in_out, idname, name);
3073 if (in_out == SOCK_IN) {
3074 BLI_insertlinkbefore(&ntree->inputs, next_sock, iosock);
3075 ntree->update |= NTREE_UPDATE_GROUP_IN;
3076 }
3077 else if (in_out == SOCK_OUT) {
3078 BLI_insertlinkbefore(&ntree->outputs, next_sock, iosock);
3079 ntree->update |= NTREE_UPDATE_GROUP_OUT;
3080 }
3081 return iosock;
3082 }
3083
ntreeAddSocketInterfaceFromSocket(bNodeTree * ntree,bNode * from_node,bNodeSocket * from_sock)3084 struct bNodeSocket *ntreeAddSocketInterfaceFromSocket(bNodeTree *ntree,
3085 bNode *from_node,
3086 bNodeSocket *from_sock)
3087 {
3088 bNodeSocket *iosock = ntreeAddSocketInterface(
3089 ntree, from_sock->in_out, from_sock->idname, from_sock->name);
3090 if (iosock) {
3091 if (iosock->typeinfo->interface_from_socket) {
3092 iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock);
3093 }
3094 }
3095 return iosock;
3096 }
3097
ntreeInsertSocketInterfaceFromSocket(bNodeTree * ntree,bNodeSocket * next_sock,bNode * from_node,bNodeSocket * from_sock)3098 struct bNodeSocket *ntreeInsertSocketInterfaceFromSocket(bNodeTree *ntree,
3099 bNodeSocket *next_sock,
3100 bNode *from_node,
3101 bNodeSocket *from_sock)
3102 {
3103 bNodeSocket *iosock = ntreeInsertSocketInterface(
3104 ntree, from_sock->in_out, from_sock->idname, next_sock, from_sock->name);
3105 if (iosock) {
3106 if (iosock->typeinfo->interface_from_socket) {
3107 iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock);
3108 }
3109 }
3110 return iosock;
3111 }
3112
ntreeRemoveSocketInterface(bNodeTree * ntree,bNodeSocket * sock)3113 void ntreeRemoveSocketInterface(bNodeTree *ntree, bNodeSocket *sock)
3114 {
3115 /* this is fast, this way we don't need an in_out argument */
3116 BLI_remlink(&ntree->inputs, sock);
3117 BLI_remlink(&ntree->outputs, sock);
3118
3119 node_socket_interface_free(ntree, sock, true);
3120 MEM_freeN(sock);
3121
3122 ntree->update |= NTREE_UPDATE_GROUP;
3123 }
3124
3125 /* generates a valid RNA identifier from the node tree name */
ntree_interface_identifier_base(bNodeTree * ntree,char * base)3126 static void ntree_interface_identifier_base(bNodeTree *ntree, char *base)
3127 {
3128 /* generate a valid RNA identifier */
3129 sprintf(base, "NodeTreeInterface_%s", ntree->id.name + 2);
3130 RNA_identifier_sanitize(base, false);
3131 }
3132
3133 /* check if the identifier is already in use */
ntree_interface_unique_identifier_check(void * UNUSED (data),const char * identifier)3134 static bool ntree_interface_unique_identifier_check(void *UNUSED(data), const char *identifier)
3135 {
3136 return (RNA_struct_find(identifier) != NULL);
3137 }
3138
3139 /* generates the actual unique identifier and ui name and description */
ntree_interface_identifier(bNodeTree * ntree,const char * base,char * identifier,int maxlen,char * name,char * description)3140 static void ntree_interface_identifier(bNodeTree *ntree,
3141 const char *base,
3142 char *identifier,
3143 int maxlen,
3144 char *name,
3145 char *description)
3146 {
3147 /* There is a possibility that different node tree names get mapped to the same identifier
3148 * after sanitation (e.g. "SomeGroup_A", "SomeGroup.A" both get sanitized to "SomeGroup_A").
3149 * On top of the sanitized id string add a number suffix if necessary to avoid duplicates.
3150 */
3151 identifier[0] = '\0';
3152 BLI_uniquename_cb(ntree_interface_unique_identifier_check, NULL, base, '_', identifier, maxlen);
3153
3154 sprintf(name, "Node Tree %s Interface", ntree->id.name + 2);
3155 sprintf(description, "Interface properties of node group %s", ntree->id.name + 2);
3156 }
3157
ntree_interface_type_create(bNodeTree * ntree)3158 static void ntree_interface_type_create(bNodeTree *ntree)
3159 {
3160 /* strings are generated from base string + ID name, sizes are sufficient */
3161 char base[MAX_ID_NAME + 64], identifier[MAX_ID_NAME + 64], name[MAX_ID_NAME + 64],
3162 description[MAX_ID_NAME + 64];
3163
3164 /* generate a valid RNA identifier */
3165 ntree_interface_identifier_base(ntree, base);
3166 ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description);
3167
3168 /* register a subtype of PropertyGroup */
3169 StructRNA *srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_PropertyGroup);
3170 RNA_def_struct_ui_text(srna, name, description);
3171 RNA_def_struct_duplicate_pointers(&BLENDER_RNA, srna);
3172
3173 /* associate the RNA type with the node tree */
3174 ntree->interface_type = srna;
3175 RNA_struct_blender_type_set(srna, ntree);
3176
3177 /* add socket properties */
3178 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->inputs) {
3179 bNodeSocketType *stype = sock->typeinfo;
3180 if (stype && stype->interface_register_properties) {
3181 stype->interface_register_properties(ntree, sock, srna);
3182 }
3183 }
3184 LISTBASE_FOREACH (bNodeSocket *, sock, &ntree->outputs) {
3185 bNodeSocketType *stype = sock->typeinfo;
3186 if (stype && stype->interface_register_properties) {
3187 stype->interface_register_properties(ntree, sock, srna);
3188 }
3189 }
3190 }
3191
ntreeInterfaceTypeGet(bNodeTree * ntree,int create)3192 StructRNA *ntreeInterfaceTypeGet(bNodeTree *ntree, int create)
3193 {
3194 if (ntree->interface_type) {
3195 /* strings are generated from base string + ID name, sizes are sufficient */
3196 char base[MAX_ID_NAME + 64], identifier[MAX_ID_NAME + 64], name[MAX_ID_NAME + 64],
3197 description[MAX_ID_NAME + 64];
3198
3199 /* A bit of a hack: when changing the ID name, update the RNA type identifier too,
3200 * so that the names match. This is not strictly necessary to keep it working,
3201 * but better for identifying associated NodeTree blocks and RNA types.
3202 */
3203 StructRNA *srna = ntree->interface_type;
3204
3205 ntree_interface_identifier_base(ntree, base);
3206
3207 /* RNA identifier may have a number suffix, but should start with the idbase string */
3208 if (!STREQLEN(RNA_struct_identifier(srna), base, sizeof(base))) {
3209 /* generate new unique RNA identifier from the ID name */
3210 ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description);
3211
3212 /* rename the RNA type */
3213 RNA_def_struct_free_pointers(&BLENDER_RNA, srna);
3214 RNA_def_struct_identifier(&BLENDER_RNA, srna, identifier);
3215 RNA_def_struct_ui_text(srna, name, description);
3216 RNA_def_struct_duplicate_pointers(&BLENDER_RNA, srna);
3217 }
3218 }
3219 else if (create) {
3220 ntree_interface_type_create(ntree);
3221 }
3222
3223 return ntree->interface_type;
3224 }
3225
ntreeInterfaceTypeFree(bNodeTree * ntree)3226 void ntreeInterfaceTypeFree(bNodeTree *ntree)
3227 {
3228 if (ntree->interface_type) {
3229 RNA_struct_free(&BLENDER_RNA, ntree->interface_type);
3230 ntree->interface_type = NULL;
3231 }
3232 }
3233
ntreeInterfaceTypeUpdate(bNodeTree * ntree)3234 void ntreeInterfaceTypeUpdate(bNodeTree *ntree)
3235 {
3236 /* XXX it would be sufficient to just recreate all properties
3237 * instead of re-registering the whole struct type,
3238 * but there is currently no good way to do this in the RNA functions.
3239 * Overhead should be negligible.
3240 */
3241 ntreeInterfaceTypeFree(ntree);
3242 ntree_interface_type_create(ntree);
3243 }
3244
3245 /* ************ find stuff *************** */
3246
ntreeFindType(const bNodeTree * ntree,int type)3247 bNode *ntreeFindType(const bNodeTree *ntree, int type)
3248 {
3249 if (ntree) {
3250 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3251 if (node->type == type) {
3252 return node;
3253 }
3254 }
3255 }
3256 return NULL;
3257 }
3258
ntreeHasType(const bNodeTree * ntree,int type)3259 bool ntreeHasType(const bNodeTree *ntree, int type)
3260 {
3261 return ntreeFindType(ntree, type) != NULL;
3262 }
3263
ntreeHasTree(const bNodeTree * ntree,const bNodeTree * lookup)3264 bool ntreeHasTree(const bNodeTree *ntree, const bNodeTree *lookup)
3265 {
3266 if (ntree == lookup) {
3267 return true;
3268 }
3269 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3270 if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id) {
3271 if (ntreeHasTree((bNodeTree *)node->id, lookup)) {
3272 return true;
3273 }
3274 }
3275 }
3276 return false;
3277 }
3278
nodeFindLink(bNodeTree * ntree,bNodeSocket * from,bNodeSocket * to)3279 bNodeLink *nodeFindLink(bNodeTree *ntree, bNodeSocket *from, bNodeSocket *to)
3280 {
3281 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
3282 if (link->fromsock == from && link->tosock == to) {
3283 return link;
3284 }
3285 if (link->fromsock == to && link->tosock == from) { /* hrms? */
3286 return link;
3287 }
3288 }
3289 return NULL;
3290 }
3291
nodeCountSocketLinks(bNodeTree * ntree,bNodeSocket * sock)3292 int nodeCountSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
3293 {
3294 int tot = 0;
3295 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
3296 if (link->fromsock == sock || link->tosock == sock) {
3297 tot++;
3298 }
3299 }
3300 return tot;
3301 }
3302
nodeGetActive(bNodeTree * ntree)3303 bNode *nodeGetActive(bNodeTree *ntree)
3304 {
3305 if (ntree == NULL) {
3306 return NULL;
3307 }
3308
3309 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3310 if (node->flag & NODE_ACTIVE) {
3311 return node;
3312 }
3313 }
3314 return NULL;
3315 }
3316
node_get_active_id_recursive(bNodeInstanceKey active_key,bNodeInstanceKey parent_key,bNodeTree * ntree,short idtype)3317 static bNode *node_get_active_id_recursive(bNodeInstanceKey active_key,
3318 bNodeInstanceKey parent_key,
3319 bNodeTree *ntree,
3320 short idtype)
3321 {
3322 if (parent_key.value == active_key.value || active_key.value == 0) {
3323 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3324 if (node->id && GS(node->id->name) == idtype) {
3325 if (node->flag & NODE_ACTIVE_ID) {
3326 return node;
3327 }
3328 }
3329 }
3330 }
3331 else {
3332 /* no node with active ID in this tree, look inside groups */
3333 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3334 if (node->type == NODE_GROUP) {
3335 bNodeTree *group = (bNodeTree *)node->id;
3336 if (group) {
3337 bNodeInstanceKey group_key = BKE_node_instance_key(parent_key, ntree, node);
3338 bNode *tnode = node_get_active_id_recursive(active_key, group_key, group, idtype);
3339 if (tnode) {
3340 return tnode;
3341 }
3342 }
3343 }
3344 }
3345 }
3346 return NULL;
3347 }
3348
3349 /* two active flags, ID nodes have special flag for buttons display */
nodeGetActiveID(bNodeTree * ntree,short idtype)3350 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
3351 {
3352 if (ntree) {
3353 return node_get_active_id_recursive(
3354 ntree->active_viewer_key, NODE_INSTANCE_KEY_BASE, ntree, idtype);
3355 }
3356 return NULL;
3357 }
3358
nodeSetActiveID(bNodeTree * ntree,short idtype,ID * id)3359 bool nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
3360 {
3361 bool ok = false;
3362
3363 if (ntree == NULL) {
3364 return ok;
3365 }
3366
3367 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3368 if (node->id && GS(node->id->name) == idtype) {
3369 if (id && ok == false && node->id == id) {
3370 node->flag |= NODE_ACTIVE_ID;
3371 ok = true;
3372 }
3373 else {
3374 node->flag &= ~NODE_ACTIVE_ID;
3375 }
3376 }
3377 }
3378
3379 /* update all groups linked from here
3380 * if active ID node has been found already,
3381 * just pass NULL so other matching nodes are deactivated.
3382 */
3383 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3384 if (node->type == NODE_GROUP) {
3385 ok |= nodeSetActiveID((bNodeTree *)node->id, idtype, (ok == false ? id : NULL));
3386 }
3387 }
3388
3389 return ok;
3390 }
3391
3392 /* two active flags, ID nodes have special flag for buttons display */
nodeClearActiveID(bNodeTree * ntree,short idtype)3393 void nodeClearActiveID(bNodeTree *ntree, short idtype)
3394 {
3395 if (ntree == NULL) {
3396 return;
3397 }
3398
3399 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3400 if (node->id && GS(node->id->name) == idtype) {
3401 node->flag &= ~NODE_ACTIVE_ID;
3402 }
3403 }
3404 }
3405
nodeSetSelected(bNode * node,bool select)3406 void nodeSetSelected(bNode *node, bool select)
3407 {
3408 if (select) {
3409 node->flag |= NODE_SELECT;
3410 }
3411 else {
3412 node->flag &= ~NODE_SELECT;
3413
3414 /* deselect sockets too */
3415 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
3416 sock->flag &= ~NODE_SELECT;
3417 }
3418 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
3419 sock->flag &= ~NODE_SELECT;
3420 }
3421 }
3422 }
3423
nodeClearActive(bNodeTree * ntree)3424 void nodeClearActive(bNodeTree *ntree)
3425 {
3426 if (ntree == NULL) {
3427 return;
3428 }
3429
3430 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3431 node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_ID);
3432 }
3433 }
3434
3435 /* two active flags, ID nodes have special flag for buttons display */
nodeSetActive(bNodeTree * ntree,bNode * node)3436 void nodeSetActive(bNodeTree *ntree, bNode *node)
3437 {
3438 /* make sure only one node is active, and only one per ID type */
3439 LISTBASE_FOREACH (bNode *, tnode, &ntree->nodes) {
3440 tnode->flag &= ~NODE_ACTIVE;
3441
3442 if (node->id && tnode->id) {
3443 if (GS(node->id->name) == GS(tnode->id->name)) {
3444 tnode->flag &= ~NODE_ACTIVE_ID;
3445 }
3446 }
3447 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) {
3448 tnode->flag &= ~NODE_ACTIVE_TEXTURE;
3449 }
3450 }
3451
3452 node->flag |= NODE_ACTIVE;
3453 if (node->id) {
3454 node->flag |= NODE_ACTIVE_ID;
3455 }
3456 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) {
3457 node->flag |= NODE_ACTIVE_TEXTURE;
3458 }
3459 }
3460
nodeSocketIsHidden(bNodeSocket * sock)3461 int nodeSocketIsHidden(bNodeSocket *sock)
3462 {
3463 return ((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0);
3464 }
3465
nodeSetSocketAvailability(bNodeSocket * sock,bool is_available)3466 void nodeSetSocketAvailability(bNodeSocket *sock, bool is_available)
3467 {
3468 if (is_available) {
3469 sock->flag &= ~SOCK_UNAVAIL;
3470 }
3471 else {
3472 sock->flag |= SOCK_UNAVAIL;
3473 }
3474 }
3475
nodeSocketLinkLimit(struct bNodeSocket * sock)3476 int nodeSocketLinkLimit(struct bNodeSocket *sock)
3477 {
3478 bNodeSocketType *stype = sock->typeinfo;
3479 if (stype != NULL && stype->use_link_limits_of_type) {
3480 int limit = (sock->in_out == SOCK_IN) ? stype->input_link_limit : stype->output_link_limit;
3481 return limit;
3482 }
3483
3484 return sock->limit;
3485 }
3486
3487 /* ************** Node Clipboard *********** */
3488
3489 #define USE_NODE_CB_VALIDATE
3490
3491 #ifdef USE_NODE_CB_VALIDATE
3492 /**
3493 * This data structure is to validate the node on creation,
3494 * otherwise we may reference missing data.
3495 *
3496 * Currently its only used for ID's, but nodes may one day
3497 * reference other pointers which need validation.
3498 */
3499 typedef struct bNodeClipboardExtraInfo {
3500 struct bNodeClipboardExtraInfo *next, *prev;
3501 ID *id;
3502 char id_name[MAX_ID_NAME];
3503 char library_name[FILE_MAX];
3504 } bNodeClipboardExtraInfo;
3505 #endif /* USE_NODE_CB_VALIDATE */
3506
3507 typedef struct bNodeClipboard {
3508 ListBase nodes;
3509
3510 #ifdef USE_NODE_CB_VALIDATE
3511 ListBase nodes_extra_info;
3512 #endif
3513
3514 ListBase links;
3515 int type;
3516 } bNodeClipboard;
3517
3518 static bNodeClipboard node_clipboard = {{NULL}};
3519
BKE_node_clipboard_init(struct bNodeTree * ntree)3520 void BKE_node_clipboard_init(struct bNodeTree *ntree)
3521 {
3522 node_clipboard.type = ntree->type;
3523 }
3524
BKE_node_clipboard_clear(void)3525 void BKE_node_clipboard_clear(void)
3526 {
3527 LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &node_clipboard.links) {
3528 nodeRemLink(NULL, link);
3529 }
3530 BLI_listbase_clear(&node_clipboard.links);
3531
3532 LISTBASE_FOREACH_MUTABLE (bNode *, node, &node_clipboard.nodes) {
3533 node_free_node(NULL, node);
3534 }
3535 BLI_listbase_clear(&node_clipboard.nodes);
3536
3537 #ifdef USE_NODE_CB_VALIDATE
3538 BLI_freelistN(&node_clipboard.nodes_extra_info);
3539 #endif
3540 }
3541
3542 /* return false when one or more ID's are lost */
BKE_node_clipboard_validate(void)3543 bool BKE_node_clipboard_validate(void)
3544 {
3545 bool ok = true;
3546
3547 #ifdef USE_NODE_CB_VALIDATE
3548 bNodeClipboardExtraInfo *node_info;
3549 bNode *node;
3550
3551 /* lists must be aligned */
3552 BLI_assert(BLI_listbase_count(&node_clipboard.nodes) ==
3553 BLI_listbase_count(&node_clipboard.nodes_extra_info));
3554
3555 for (node = node_clipboard.nodes.first, node_info = node_clipboard.nodes_extra_info.first; node;
3556 node = node->next, node_info = node_info->next) {
3557 /* validate the node against the stored node info */
3558
3559 /* re-assign each loop since we may clear,
3560 * open a new file where the ID is valid, and paste again */
3561 node->id = node_info->id;
3562
3563 /* currently only validate the ID */
3564 if (node->id) {
3565 /* We want to search into current blend file, so using G_MAIN is valid here too. */
3566 ListBase *lb = which_libbase(G_MAIN, GS(node_info->id_name));
3567 BLI_assert(lb != NULL);
3568
3569 if (BLI_findindex(lb, node_info->id) == -1) {
3570 /* may assign NULL */
3571 node->id = BLI_findstring(lb, node_info->id_name + 2, offsetof(ID, name) + 2);
3572
3573 if (node->id == NULL) {
3574 ok = false;
3575 }
3576 }
3577 }
3578 }
3579 #endif /* USE_NODE_CB_VALIDATE */
3580
3581 return ok;
3582 }
3583
BKE_node_clipboard_add_node(bNode * node)3584 void BKE_node_clipboard_add_node(bNode *node)
3585 {
3586 #ifdef USE_NODE_CB_VALIDATE
3587 /* add extra info */
3588 bNodeClipboardExtraInfo *node_info = MEM_mallocN(sizeof(bNodeClipboardExtraInfo),
3589 "bNodeClipboardExtraInfo");
3590
3591 node_info->id = node->id;
3592 if (node->id) {
3593 BLI_strncpy(node_info->id_name, node->id->name, sizeof(node_info->id_name));
3594 if (ID_IS_LINKED(node->id)) {
3595 BLI_strncpy(
3596 node_info->library_name, node->id->lib->filepath_abs, sizeof(node_info->library_name));
3597 }
3598 else {
3599 node_info->library_name[0] = '\0';
3600 }
3601 }
3602 else {
3603 node_info->id_name[0] = '\0';
3604 node_info->library_name[0] = '\0';
3605 }
3606 BLI_addtail(&node_clipboard.nodes_extra_info, node_info);
3607 /* end extra info */
3608 #endif /* USE_NODE_CB_VALIDATE */
3609
3610 /* add node */
3611 BLI_addtail(&node_clipboard.nodes, node);
3612 }
3613
BKE_node_clipboard_add_link(bNodeLink * link)3614 void BKE_node_clipboard_add_link(bNodeLink *link)
3615 {
3616 BLI_addtail(&node_clipboard.links, link);
3617 }
3618
BKE_node_clipboard_get_nodes(void)3619 const ListBase *BKE_node_clipboard_get_nodes(void)
3620 {
3621 return &node_clipboard.nodes;
3622 }
3623
BKE_node_clipboard_get_links(void)3624 const ListBase *BKE_node_clipboard_get_links(void)
3625 {
3626 return &node_clipboard.links;
3627 }
3628
BKE_node_clipboard_get_type(void)3629 int BKE_node_clipboard_get_type(void)
3630 {
3631 return node_clipboard.type;
3632 }
3633
BKE_node_clipboard_free(void)3634 void BKE_node_clipboard_free(void)
3635 {
3636 BKE_node_clipboard_validate();
3637 BKE_node_clipboard_clear();
3638 }
3639
3640 /* Node Instance Hash */
3641
3642 /* magic number for initial hash key */
3643 const bNodeInstanceKey NODE_INSTANCE_KEY_BASE = {5381};
3644 const bNodeInstanceKey NODE_INSTANCE_KEY_NONE = {0};
3645
3646 /* Generate a hash key from ntree and node names
3647 * Uses the djb2 algorithm with xor by Bernstein:
3648 * http://www.cse.yorku.ca/~oz/hash.html
3649 */
node_hash_int_str(bNodeInstanceKey hash,const char * str)3650 static bNodeInstanceKey node_hash_int_str(bNodeInstanceKey hash, const char *str)
3651 {
3652 char c;
3653
3654 while ((c = *str++)) {
3655 hash.value = ((hash.value << 5) + hash.value) ^ c; /* (hash * 33) ^ c */
3656 }
3657
3658 /* separator '\0' character, to avoid ambiguity from concatenated strings */
3659 hash.value = (hash.value << 5) + hash.value; /* hash * 33 */
3660
3661 return hash;
3662 }
3663
BKE_node_instance_key(bNodeInstanceKey parent_key,bNodeTree * ntree,bNode * node)3664 bNodeInstanceKey BKE_node_instance_key(bNodeInstanceKey parent_key, bNodeTree *ntree, bNode *node)
3665 {
3666 bNodeInstanceKey key;
3667
3668 key = node_hash_int_str(parent_key, ntree->id.name + 2);
3669
3670 if (node) {
3671 key = node_hash_int_str(key, node->name);
3672 }
3673
3674 return key;
3675 }
3676
node_instance_hash_key(const void * key)3677 static unsigned int node_instance_hash_key(const void *key)
3678 {
3679 return ((const bNodeInstanceKey *)key)->value;
3680 }
3681
node_instance_hash_key_cmp(const void * a,const void * b)3682 static bool node_instance_hash_key_cmp(const void *a, const void *b)
3683 {
3684 unsigned int value_a = ((const bNodeInstanceKey *)a)->value;
3685 unsigned int value_b = ((const bNodeInstanceKey *)b)->value;
3686
3687 return (value_a != value_b);
3688 }
3689
BKE_node_instance_hash_new(const char * info)3690 bNodeInstanceHash *BKE_node_instance_hash_new(const char *info)
3691 {
3692 bNodeInstanceHash *hash = MEM_mallocN(sizeof(bNodeInstanceHash), info);
3693 hash->ghash = BLI_ghash_new(
3694 node_instance_hash_key, node_instance_hash_key_cmp, "node instance hash ghash");
3695 return hash;
3696 }
3697
BKE_node_instance_hash_free(bNodeInstanceHash * hash,bNodeInstanceValueFP valfreefp)3698 void BKE_node_instance_hash_free(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp)
3699 {
3700 BLI_ghash_free(hash->ghash, NULL, (GHashValFreeFP)valfreefp);
3701 MEM_freeN(hash);
3702 }
3703
BKE_node_instance_hash_insert(bNodeInstanceHash * hash,bNodeInstanceKey key,void * value)3704 void BKE_node_instance_hash_insert(bNodeInstanceHash *hash, bNodeInstanceKey key, void *value)
3705 {
3706 bNodeInstanceHashEntry *entry = value;
3707 entry->key = key;
3708 entry->tag = 0;
3709 BLI_ghash_insert(hash->ghash, &entry->key, value);
3710 }
3711
BKE_node_instance_hash_lookup(bNodeInstanceHash * hash,bNodeInstanceKey key)3712 void *BKE_node_instance_hash_lookup(bNodeInstanceHash *hash, bNodeInstanceKey key)
3713 {
3714 return BLI_ghash_lookup(hash->ghash, &key);
3715 }
3716
BKE_node_instance_hash_remove(bNodeInstanceHash * hash,bNodeInstanceKey key,bNodeInstanceValueFP valfreefp)3717 int BKE_node_instance_hash_remove(bNodeInstanceHash *hash,
3718 bNodeInstanceKey key,
3719 bNodeInstanceValueFP valfreefp)
3720 {
3721 return BLI_ghash_remove(hash->ghash, &key, NULL, (GHashValFreeFP)valfreefp);
3722 }
3723
BKE_node_instance_hash_clear(bNodeInstanceHash * hash,bNodeInstanceValueFP valfreefp)3724 void BKE_node_instance_hash_clear(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp)
3725 {
3726 BLI_ghash_clear(hash->ghash, NULL, (GHashValFreeFP)valfreefp);
3727 }
3728
BKE_node_instance_hash_pop(bNodeInstanceHash * hash,bNodeInstanceKey key)3729 void *BKE_node_instance_hash_pop(bNodeInstanceHash *hash, bNodeInstanceKey key)
3730 {
3731 return BLI_ghash_popkey(hash->ghash, &key, NULL);
3732 }
3733
BKE_node_instance_hash_haskey(bNodeInstanceHash * hash,bNodeInstanceKey key)3734 int BKE_node_instance_hash_haskey(bNodeInstanceHash *hash, bNodeInstanceKey key)
3735 {
3736 return BLI_ghash_haskey(hash->ghash, &key);
3737 }
3738
BKE_node_instance_hash_size(bNodeInstanceHash * hash)3739 int BKE_node_instance_hash_size(bNodeInstanceHash *hash)
3740 {
3741 return BLI_ghash_len(hash->ghash);
3742 }
3743
BKE_node_instance_hash_clear_tags(bNodeInstanceHash * hash)3744 void BKE_node_instance_hash_clear_tags(bNodeInstanceHash *hash)
3745 {
3746 bNodeInstanceHashIterator iter;
3747
3748 NODE_INSTANCE_HASH_ITER (iter, hash) {
3749 bNodeInstanceHashEntry *value = BKE_node_instance_hash_iterator_get_value(&iter);
3750
3751 value->tag = 0;
3752 }
3753 }
3754
BKE_node_instance_hash_tag(bNodeInstanceHash * UNUSED (hash),void * value)3755 void BKE_node_instance_hash_tag(bNodeInstanceHash *UNUSED(hash), void *value)
3756 {
3757 bNodeInstanceHashEntry *entry = value;
3758 entry->tag = 1;
3759 }
3760
BKE_node_instance_hash_tag_key(bNodeInstanceHash * hash,bNodeInstanceKey key)3761 bool BKE_node_instance_hash_tag_key(bNodeInstanceHash *hash, bNodeInstanceKey key)
3762 {
3763 bNodeInstanceHashEntry *entry = BKE_node_instance_hash_lookup(hash, key);
3764
3765 if (entry) {
3766 entry->tag = 1;
3767 return true;
3768 }
3769
3770 return false;
3771 }
3772
BKE_node_instance_hash_remove_untagged(bNodeInstanceHash * hash,bNodeInstanceValueFP valfreefp)3773 void BKE_node_instance_hash_remove_untagged(bNodeInstanceHash *hash,
3774 bNodeInstanceValueFP valfreefp)
3775 {
3776 /* NOTE: Hash must not be mutated during iterating!
3777 * Store tagged entries in a separate list and remove items afterward.
3778 */
3779 bNodeInstanceKey *untagged = MEM_mallocN(sizeof(bNodeInstanceKey) *
3780 BKE_node_instance_hash_size(hash),
3781 "temporary node instance key list");
3782 bNodeInstanceHashIterator iter;
3783 int num_untagged = 0;
3784 NODE_INSTANCE_HASH_ITER (iter, hash) {
3785 bNodeInstanceHashEntry *value = BKE_node_instance_hash_iterator_get_value(&iter);
3786
3787 if (!value->tag) {
3788 untagged[num_untagged++] = BKE_node_instance_hash_iterator_get_key(&iter);
3789 }
3790 }
3791
3792 for (int i = 0; i < num_untagged; i++) {
3793 BKE_node_instance_hash_remove(hash, untagged[i], valfreefp);
3794 }
3795
3796 MEM_freeN(untagged);
3797 }
3798
3799 /* ************** dependency stuff *********** */
3800
3801 /* node is guaranteed to be not checked before */
node_get_deplist_recurs(bNodeTree * ntree,bNode * node,bNode *** nsort)3802 static int node_get_deplist_recurs(bNodeTree *ntree, bNode *node, bNode ***nsort)
3803 {
3804 int level = 0xFFF;
3805
3806 node->done = true;
3807
3808 /* check linked nodes */
3809 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
3810 if (link->tonode == node) {
3811 bNode *fromnode = link->fromnode;
3812 if (fromnode->done == 0) {
3813 fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort);
3814 }
3815 if (fromnode->level <= level) {
3816 level = fromnode->level - 1;
3817 }
3818 }
3819 }
3820
3821 /* check parent node */
3822 if (node->parent) {
3823 if (node->parent->done == 0) {
3824 node->parent->level = node_get_deplist_recurs(ntree, node->parent, nsort);
3825 }
3826 if (node->parent->level <= level) {
3827 level = node->parent->level - 1;
3828 }
3829 }
3830
3831 if (nsort) {
3832 **nsort = node;
3833 (*nsort)++;
3834 }
3835
3836 return level;
3837 }
3838
ntreeGetDependencyList(struct bNodeTree * ntree,struct bNode *** deplist,int * totnodes)3839 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
3840 {
3841 *totnodes = 0;
3842
3843 /* first clear data */
3844 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3845 node->done = false;
3846 (*totnodes)++;
3847 }
3848 if (*totnodes == 0) {
3849 *deplist = NULL;
3850 return;
3851 }
3852
3853 bNode **nsort;
3854 nsort = *deplist = MEM_callocN((*totnodes) * sizeof(bNode *), "sorted node array");
3855
3856 /* recursive check */
3857 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3858 if (node->done == 0) {
3859 node->level = node_get_deplist_recurs(ntree, node, &nsort);
3860 }
3861 }
3862 }
3863
3864 /* only updates node->level for detecting cycles links */
ntree_update_node_level(bNodeTree * ntree)3865 static void ntree_update_node_level(bNodeTree *ntree)
3866 {
3867 /* first clear tag */
3868 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3869 node->done = false;
3870 }
3871
3872 /* recursive check */
3873 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3874 if (node->done == 0) {
3875 node->level = node_get_deplist_recurs(ntree, node, NULL);
3876 }
3877 }
3878 }
3879
ntreeTagUsedSockets(bNodeTree * ntree)3880 void ntreeTagUsedSockets(bNodeTree *ntree)
3881 {
3882 /* first clear data */
3883 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3884 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
3885 sock->flag &= ~SOCK_IN_USE;
3886 }
3887 LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
3888 sock->flag &= ~SOCK_IN_USE;
3889 }
3890 }
3891
3892 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
3893 link->fromsock->flag |= SOCK_IN_USE;
3894 link->tosock->flag |= SOCK_IN_USE;
3895 }
3896 }
3897
ntree_update_link_pointers(bNodeTree * ntree)3898 static void ntree_update_link_pointers(bNodeTree *ntree)
3899 {
3900 /* first clear data */
3901 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3902 LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
3903 sock->link = NULL;
3904 }
3905 }
3906
3907 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
3908 link->tosock->link = link;
3909 }
3910
3911 ntreeTagUsedSockets(ntree);
3912 }
3913
ntree_validate_links(bNodeTree * ntree)3914 static void ntree_validate_links(bNodeTree *ntree)
3915 {
3916 LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
3917 link->flag |= NODE_LINK_VALID;
3918 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level) {
3919 link->flag &= ~NODE_LINK_VALID;
3920 }
3921 else if (ntree->typeinfo->validate_link) {
3922 if (!ntree->typeinfo->validate_link(ntree, link)) {
3923 link->flag &= ~NODE_LINK_VALID;
3924 }
3925 }
3926 }
3927 }
3928
ntreeUpdateAllNew(Main * main)3929 void ntreeUpdateAllNew(Main *main)
3930 {
3931 /* Update all new node trees on file read or append, to add/remove sockets
3932 * in groups nodes if the group changed, and handle any update flags that
3933 * might have been set in file reading or versioning. */
3934 FOREACH_NODETREE_BEGIN (main, ntree, owner_id) {
3935 if (owner_id->tag & LIB_TAG_NEW) {
3936 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3937 if (node->typeinfo->group_update_func) {
3938 node->typeinfo->group_update_func(ntree, node);
3939 }
3940 }
3941
3942 ntreeUpdateTree(NULL, ntree);
3943 }
3944 }
3945 FOREACH_NODETREE_END;
3946 }
3947
ntreeUpdateAllUsers(Main * main,ID * ngroup)3948 void ntreeUpdateAllUsers(Main *main, ID *ngroup)
3949 {
3950 /* Update all users of ngroup, to add/remove sockets as needed. */
3951 FOREACH_NODETREE_BEGIN (main, ntree, owner_id) {
3952 bool need_update = false;
3953
3954 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3955 if (node->id == ngroup) {
3956 if (node->typeinfo->group_update_func) {
3957 node->typeinfo->group_update_func(ntree, node);
3958 }
3959
3960 need_update = true;
3961 }
3962 }
3963
3964 if (need_update) {
3965 ntreeUpdateTree(NULL, ntree);
3966 }
3967 }
3968 FOREACH_NODETREE_END;
3969 }
3970
ntreeUpdateTree(Main * bmain,bNodeTree * ntree)3971 void ntreeUpdateTree(Main *bmain, bNodeTree *ntree)
3972 {
3973 if (!ntree) {
3974 return;
3975 }
3976
3977 /* Avoid re-entrant updates, can be caused by RNA update callbacks. */
3978 if (ntree->is_updating) {
3979 return;
3980 }
3981 ntree->is_updating = true;
3982
3983 if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
3984 /* set the bNodeSocket->link pointers */
3985 ntree_update_link_pointers(ntree);
3986 }
3987
3988 /* update individual nodes */
3989 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3990 /* node tree update tags override individual node update flags */
3991 if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
3992 if (node->typeinfo->updatefunc) {
3993 node->typeinfo->updatefunc(ntree, node);
3994 }
3995
3996 nodeUpdateInternalLinks(ntree, node);
3997 }
3998 }
3999
4000 /* generic tree update callback */
4001 if (ntree->typeinfo->update) {
4002 ntree->typeinfo->update(ntree);
4003 }
4004 /* XXX this should be moved into the tree type update callback for tree supporting node groups.
4005 * Currently the node tree interface is still a generic feature of the base NodeTree type.
4006 */
4007 if (ntree->update & NTREE_UPDATE_GROUP) {
4008 ntreeInterfaceTypeUpdate(ntree);
4009 }
4010
4011 if (bmain) {
4012 ntreeUpdateAllUsers(bmain, &ntree->id);
4013 }
4014
4015 if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
4016 /* node updates can change sockets or links, repeat link pointer update afterward */
4017 ntree_update_link_pointers(ntree);
4018
4019 /* update the node level from link dependencies */
4020 ntree_update_node_level(ntree);
4021
4022 /* check link validity */
4023 ntree_validate_links(ntree);
4024 }
4025
4026 /* clear update flags */
4027 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
4028 node->update = 0;
4029 }
4030 ntree->update = 0;
4031
4032 ntree->is_updating = false;
4033 }
4034
nodeUpdate(bNodeTree * ntree,bNode * node)4035 void nodeUpdate(bNodeTree *ntree, bNode *node)
4036 {
4037 /* Avoid re-entrant updates, can be caused by RNA update callbacks. */
4038 if (ntree->is_updating) {
4039 return;
4040 }
4041 ntree->is_updating = true;
4042
4043 if (node->typeinfo->updatefunc) {
4044 node->typeinfo->updatefunc(ntree, node);
4045 }
4046
4047 nodeUpdateInternalLinks(ntree, node);
4048
4049 /* clear update flag */
4050 node->update = 0;
4051
4052 ntree->is_updating = false;
4053 }
4054
nodeUpdateID(bNodeTree * ntree,ID * id)4055 bool nodeUpdateID(bNodeTree *ntree, ID *id)
4056 {
4057 bool changed = false;
4058
4059 if (ELEM(NULL, id, ntree)) {
4060 return changed;
4061 }
4062
4063 /* Avoid re-entrant updates, can be caused by RNA update callbacks. */
4064 if (ntree->is_updating) {
4065 return changed;
4066 }
4067 ntree->is_updating = true;
4068
4069 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
4070 if (node->id == id) {
4071 changed = true;
4072 node->update |= NODE_UPDATE_ID;
4073 if (node->typeinfo->updatefunc) {
4074 node->typeinfo->updatefunc(ntree, node);
4075 }
4076 /* clear update flag */
4077 node->update = 0;
4078 }
4079 }
4080
4081 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
4082 nodeUpdateInternalLinks(ntree, node);
4083 }
4084
4085 ntree->is_updating = false;
4086 return changed;
4087 }
4088
nodeUpdateInternalLinks(bNodeTree * ntree,bNode * node)4089 void nodeUpdateInternalLinks(bNodeTree *ntree, bNode *node)
4090 {
4091 BLI_freelistN(&node->internal_links);
4092
4093 if (node->typeinfo && node->typeinfo->update_internal_links) {
4094 node->typeinfo->update_internal_links(ntree, node);
4095 }
4096 }
4097
4098 /* ************* node type access ********** */
4099
nodeLabel(bNodeTree * ntree,bNode * node,char * label,int maxlen)4100 void nodeLabel(bNodeTree *ntree, bNode *node, char *label, int maxlen)
4101 {
4102 label[0] = '\0';
4103
4104 if (node->label[0] != '\0') {
4105 BLI_strncpy(label, node->label, maxlen);
4106 }
4107 else if (node->typeinfo->labelfunc) {
4108 node->typeinfo->labelfunc(ntree, node, label, maxlen);
4109 }
4110
4111 /* The previous methods (labelfunc) could not provide an adequate label for the node. */
4112 if (label[0] == '\0') {
4113 /* Kind of hacky and weak... Ideally would be better to use RNA here. :| */
4114 const char *tmp = CTX_IFACE_(BLT_I18NCONTEXT_ID_NODETREE, node->typeinfo->ui_name);
4115 if (tmp == node->typeinfo->ui_name) {
4116 tmp = IFACE_(node->typeinfo->ui_name);
4117 }
4118 BLI_strncpy(label, tmp, maxlen);
4119 }
4120 }
4121
4122 /* Get node socket label if it is set */
nodeSocketLabel(const bNodeSocket * sock)4123 const char *nodeSocketLabel(const bNodeSocket *sock)
4124 {
4125 return (sock->label[0] != '\0') ? sock->label : sock->name;
4126 }
4127
node_type_base_defaults(bNodeType * ntype)4128 static void node_type_base_defaults(bNodeType *ntype)
4129 {
4130 /* default size values */
4131 node_type_size_preset(ntype, NODE_SIZE_DEFAULT);
4132 ntype->height = 100;
4133 ntype->minheight = 30;
4134 ntype->maxheight = FLT_MAX;
4135 }
4136
4137 /* allow this node for any tree type */
node_poll_default(bNodeType * UNUSED (ntype),bNodeTree * UNUSED (ntree))4138 static bool node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *UNUSED(ntree))
4139 {
4140 return true;
4141 }
4142
4143 /* use the basic poll function */
node_poll_instance_default(bNode * node,bNodeTree * ntree)4144 static bool node_poll_instance_default(bNode *node, bNodeTree *ntree)
4145 {
4146 return node->typeinfo->poll(node->typeinfo, ntree);
4147 }
4148
4149 /* NOLINTNEXTLINE: readability-function-size */
node_type_base(bNodeType * ntype,int type,const char * name,short nclass,short flag)4150 void node_type_base(bNodeType *ntype, int type, const char *name, short nclass, short flag)
4151 {
4152 /* Use static type info header to map static int type to identifier string and RNA struct type.
4153 * Associate the RNA struct type with the bNodeType.
4154 * Dynamically registered nodes will create an RNA type at runtime
4155 * and call RNA_struct_blender_type_set, so this only needs to be done for old RNA types
4156 * created in makesrna, which can not be associated to a bNodeType immediately,
4157 * since bNodeTypes are registered afterward ...
4158 */
4159 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
4160 case ID: \
4161 BLI_strncpy(ntype->idname, #Category #StructName, sizeof(ntype->idname)); \
4162 ntype->rna_ext.srna = RNA_struct_find(#Category #StructName); \
4163 BLI_assert(ntype->rna_ext.srna != NULL); \
4164 RNA_struct_blender_type_set(ntype->rna_ext.srna, ntype); \
4165 break;
4166
4167 switch (type) {
4168 #include "NOD_static_types.h"
4169 }
4170
4171 /* make sure we have a valid type (everything registered) */
4172 BLI_assert(ntype->idname[0] != '\0');
4173
4174 ntype->type = type;
4175 BLI_strncpy(ntype->ui_name, name, sizeof(ntype->ui_name));
4176 ntype->nclass = nclass;
4177 ntype->flag = flag;
4178
4179 node_type_base_defaults(ntype);
4180
4181 ntype->poll = node_poll_default;
4182 ntype->poll_instance = node_poll_instance_default;
4183 }
4184
node_type_base_custom(bNodeType * ntype,const char * idname,const char * name,short nclass,short flag)4185 void node_type_base_custom(
4186 bNodeType *ntype, const char *idname, const char *name, short nclass, short flag)
4187 {
4188 BLI_strncpy(ntype->idname, idname, sizeof(ntype->idname));
4189 ntype->type = NODE_CUSTOM;
4190 BLI_strncpy(ntype->ui_name, name, sizeof(ntype->ui_name));
4191 ntype->nclass = nclass;
4192 ntype->flag = flag;
4193
4194 node_type_base_defaults(ntype);
4195 }
4196
unique_socket_template_identifier_check(void * arg,const char * name)4197 static bool unique_socket_template_identifier_check(void *arg, const char *name)
4198 {
4199 bNodeSocketTemplate *ntemp;
4200 struct {
4201 bNodeSocketTemplate *list;
4202 bNodeSocketTemplate *ntemp;
4203 } *data = arg;
4204
4205 for (ntemp = data->list; ntemp->type >= 0; ntemp++) {
4206 if (ntemp != data->ntemp) {
4207 if (STREQ(ntemp->identifier, name)) {
4208 return true;
4209 }
4210 }
4211 }
4212
4213 return false;
4214 }
4215
unique_socket_template_identifier(bNodeSocketTemplate * list,bNodeSocketTemplate * ntemp,const char defname[],char delim)4216 static void unique_socket_template_identifier(bNodeSocketTemplate *list,
4217 bNodeSocketTemplate *ntemp,
4218 const char defname[],
4219 char delim)
4220 {
4221 struct {
4222 bNodeSocketTemplate *list;
4223 bNodeSocketTemplate *ntemp;
4224 } data;
4225 data.list = list;
4226 data.ntemp = ntemp;
4227
4228 BLI_uniquename_cb(unique_socket_template_identifier_check,
4229 &data,
4230 defname,
4231 delim,
4232 ntemp->identifier,
4233 sizeof(ntemp->identifier));
4234 }
4235
node_type_socket_templates(struct bNodeType * ntype,struct bNodeSocketTemplate * inputs,struct bNodeSocketTemplate * outputs)4236 void node_type_socket_templates(struct bNodeType *ntype,
4237 struct bNodeSocketTemplate *inputs,
4238 struct bNodeSocketTemplate *outputs)
4239 {
4240 ntype->inputs = inputs;
4241 ntype->outputs = outputs;
4242
4243 /* automatically generate unique identifiers */
4244 if (inputs) {
4245 /* clear identifier strings (uninitialized memory) */
4246 for (bNodeSocketTemplate *ntemp = inputs; ntemp->type >= 0; ntemp++) {
4247 ntemp->identifier[0] = '\0';
4248 }
4249
4250 for (bNodeSocketTemplate *ntemp = inputs; ntemp->type >= 0; ntemp++) {
4251 BLI_strncpy(ntemp->identifier, ntemp->name, sizeof(ntemp->identifier));
4252 unique_socket_template_identifier(inputs, ntemp, ntemp->identifier, '_');
4253 }
4254 }
4255 if (outputs) {
4256 /* clear identifier strings (uninitialized memory) */
4257 for (bNodeSocketTemplate *ntemp = outputs; ntemp->type >= 0; ntemp++) {
4258 ntemp->identifier[0] = '\0';
4259 }
4260
4261 for (bNodeSocketTemplate *ntemp = outputs; ntemp->type >= 0; ntemp++) {
4262 BLI_strncpy(ntemp->identifier, ntemp->name, sizeof(ntemp->identifier));
4263 unique_socket_template_identifier(outputs, ntemp, ntemp->identifier, '_');
4264 }
4265 }
4266 }
4267
node_type_init(struct bNodeType * ntype,void (* initfunc)(struct bNodeTree * ntree,struct bNode * node))4268 void node_type_init(struct bNodeType *ntype,
4269 void (*initfunc)(struct bNodeTree *ntree, struct bNode *node))
4270 {
4271 ntype->initfunc = initfunc;
4272 }
4273
node_type_size(struct bNodeType * ntype,int width,int minwidth,int maxwidth)4274 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
4275 {
4276 ntype->width = width;
4277 ntype->minwidth = minwidth;
4278 if (maxwidth <= minwidth) {
4279 ntype->maxwidth = FLT_MAX;
4280 }
4281 else {
4282 ntype->maxwidth = maxwidth;
4283 }
4284 }
4285
node_type_size_preset(struct bNodeType * ntype,eNodeSizePreset size)4286 void node_type_size_preset(struct bNodeType *ntype, eNodeSizePreset size)
4287 {
4288 switch (size) {
4289 case NODE_SIZE_DEFAULT:
4290 node_type_size(ntype, 140, 100, NODE_DEFAULT_MAX_WIDTH);
4291 break;
4292 case NODE_SIZE_SMALL:
4293 node_type_size(ntype, 100, 80, NODE_DEFAULT_MAX_WIDTH);
4294 break;
4295 case NODE_SIZE_MIDDLE:
4296 node_type_size(ntype, 150, 120, NODE_DEFAULT_MAX_WIDTH);
4297 break;
4298 case NODE_SIZE_LARGE:
4299 node_type_size(ntype, 240, 140, NODE_DEFAULT_MAX_WIDTH);
4300 break;
4301 }
4302 }
4303
4304 /**
4305 * \warning Nodes defining a storage type _must_ allocate this for new nodes.
4306 * Otherwise nodes will reload as undefined (T46619).
4307 */
node_type_storage(bNodeType * ntype,const char * storagename,void (* freefunc)(struct bNode * node),void (* copyfunc)(struct bNodeTree * dest_ntree,struct bNode * dest_node,const struct bNode * src_node))4308 void node_type_storage(bNodeType *ntype,
4309 const char *storagename,
4310 void (*freefunc)(struct bNode *node),
4311 void (*copyfunc)(struct bNodeTree *dest_ntree,
4312 struct bNode *dest_node,
4313 const struct bNode *src_node))
4314 {
4315 if (storagename) {
4316 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
4317 }
4318 else {
4319 ntype->storagename[0] = '\0';
4320 }
4321 ntype->copyfunc = copyfunc;
4322 ntype->freefunc = freefunc;
4323 }
4324
node_type_label(struct bNodeType * ntype,void (* labelfunc)(struct bNodeTree * ntree,struct bNode * node,char * label,int maxlen))4325 void node_type_label(
4326 struct bNodeType *ntype,
4327 void (*labelfunc)(struct bNodeTree *ntree, struct bNode *node, char *label, int maxlen))
4328 {
4329 ntype->labelfunc = labelfunc;
4330 }
4331
node_type_update(struct bNodeType * ntype,void (* updatefunc)(struct bNodeTree * ntree,struct bNode * node))4332 void node_type_update(struct bNodeType *ntype,
4333 void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node))
4334 {
4335 ntype->updatefunc = updatefunc;
4336 }
4337
node_type_group_update(struct bNodeType * ntype,void (* group_update_func)(struct bNodeTree * ntree,struct bNode * node))4338 void node_type_group_update(struct bNodeType *ntype,
4339 void (*group_update_func)(struct bNodeTree *ntree, struct bNode *node))
4340 {
4341 ntype->group_update_func = group_update_func;
4342 }
4343
node_type_exec(struct bNodeType * ntype,NodeInitExecFunction initexecfunc,NodeFreeExecFunction freeexecfunc,NodeExecFunction execfunc)4344 void node_type_exec(struct bNodeType *ntype,
4345 NodeInitExecFunction initexecfunc,
4346 NodeFreeExecFunction freeexecfunc,
4347 NodeExecFunction execfunc)
4348 {
4349 ntype->initexecfunc = initexecfunc;
4350 ntype->freeexecfunc = freeexecfunc;
4351 ntype->execfunc = execfunc;
4352 }
4353
node_type_gpu(struct bNodeType * ntype,NodeGPUExecFunction gpufunc)4354 void node_type_gpu(struct bNodeType *ntype, NodeGPUExecFunction gpufunc)
4355 {
4356 ntype->gpufunc = gpufunc;
4357 }
4358
node_type_internal_links(bNodeType * ntype,void (* update_internal_links)(bNodeTree *,bNode *))4359 void node_type_internal_links(bNodeType *ntype,
4360 void (*update_internal_links)(bNodeTree *, bNode *))
4361 {
4362 ntype->update_internal_links = update_internal_links;
4363 }
4364
4365 /* callbacks for undefined types */
4366
node_undefined_poll(bNodeType * UNUSED (ntype),bNodeTree * UNUSED (nodetree))4367 static bool node_undefined_poll(bNodeType *UNUSED(ntype), bNodeTree *UNUSED(nodetree))
4368 {
4369 /* this type can not be added deliberately, it's just a placeholder */
4370 return false;
4371 }
4372
4373 /* register fallback types used for undefined tree, nodes, sockets */
register_undefined_types(void)4374 static void register_undefined_types(void)
4375 {
4376 /* Note: these types are not registered in the type hashes,
4377 * they are just used as placeholders in case the actual types are not registered.
4378 */
4379
4380 strcpy(NodeTreeTypeUndefined.idname, "NodeTreeUndefined");
4381 strcpy(NodeTreeTypeUndefined.ui_name, N_("Undefined"));
4382 strcpy(NodeTreeTypeUndefined.ui_description, N_("Undefined Node Tree Type"));
4383
4384 node_type_base_custom(&NodeTypeUndefined, "NodeUndefined", "Undefined", 0, 0);
4385 NodeTypeUndefined.poll = node_undefined_poll;
4386
4387 BLI_strncpy(NodeSocketTypeUndefined.idname,
4388 "NodeSocketUndefined",
4389 sizeof(NodeSocketTypeUndefined.idname));
4390 /* extra type info for standard socket types */
4391 NodeSocketTypeUndefined.type = SOCK_CUSTOM;
4392 NodeSocketTypeUndefined.subtype = PROP_NONE;
4393
4394 NodeSocketTypeUndefined.use_link_limits_of_type = true;
4395 NodeSocketTypeUndefined.input_link_limit = 0xFFF;
4396 NodeSocketTypeUndefined.output_link_limit = 0xFFF;
4397 }
4398
registerCompositNodes(void)4399 static void registerCompositNodes(void)
4400 {
4401 register_node_type_cmp_group();
4402
4403 register_node_type_cmp_rlayers();
4404 register_node_type_cmp_image();
4405 register_node_type_cmp_texture();
4406 register_node_type_cmp_value();
4407 register_node_type_cmp_rgb();
4408 register_node_type_cmp_curve_time();
4409 register_node_type_cmp_movieclip();
4410
4411 register_node_type_cmp_composite();
4412 register_node_type_cmp_viewer();
4413 register_node_type_cmp_splitviewer();
4414 register_node_type_cmp_output_file();
4415 register_node_type_cmp_view_levels();
4416
4417 register_node_type_cmp_curve_rgb();
4418 register_node_type_cmp_mix_rgb();
4419 register_node_type_cmp_hue_sat();
4420 register_node_type_cmp_brightcontrast();
4421 register_node_type_cmp_gamma();
4422 register_node_type_cmp_invert();
4423 register_node_type_cmp_alphaover();
4424 register_node_type_cmp_zcombine();
4425 register_node_type_cmp_colorbalance();
4426 register_node_type_cmp_huecorrect();
4427
4428 register_node_type_cmp_normal();
4429 register_node_type_cmp_curve_vec();
4430 register_node_type_cmp_map_value();
4431 register_node_type_cmp_map_range();
4432 register_node_type_cmp_normalize();
4433
4434 register_node_type_cmp_filter();
4435 register_node_type_cmp_blur();
4436 register_node_type_cmp_dblur();
4437 register_node_type_cmp_bilateralblur();
4438 register_node_type_cmp_vecblur();
4439 register_node_type_cmp_dilateerode();
4440 register_node_type_cmp_inpaint();
4441 register_node_type_cmp_despeckle();
4442 register_node_type_cmp_defocus();
4443 register_node_type_cmp_sunbeams();
4444 register_node_type_cmp_denoise();
4445
4446 register_node_type_cmp_valtorgb();
4447 register_node_type_cmp_rgbtobw();
4448 register_node_type_cmp_setalpha();
4449 register_node_type_cmp_idmask();
4450 register_node_type_cmp_math();
4451 register_node_type_cmp_seprgba();
4452 register_node_type_cmp_combrgba();
4453 register_node_type_cmp_sephsva();
4454 register_node_type_cmp_combhsva();
4455 register_node_type_cmp_sepyuva();
4456 register_node_type_cmp_combyuva();
4457 register_node_type_cmp_sepycca();
4458 register_node_type_cmp_combycca();
4459 register_node_type_cmp_premulkey();
4460
4461 register_node_type_cmp_diff_matte();
4462 register_node_type_cmp_distance_matte();
4463 register_node_type_cmp_chroma_matte();
4464 register_node_type_cmp_color_matte();
4465 register_node_type_cmp_channel_matte();
4466 register_node_type_cmp_color_spill();
4467 register_node_type_cmp_luma_matte();
4468 register_node_type_cmp_doubleedgemask();
4469 register_node_type_cmp_keyingscreen();
4470 register_node_type_cmp_keying();
4471 register_node_type_cmp_cryptomatte();
4472
4473 register_node_type_cmp_translate();
4474 register_node_type_cmp_rotate();
4475 register_node_type_cmp_scale();
4476 register_node_type_cmp_flip();
4477 register_node_type_cmp_crop();
4478 register_node_type_cmp_displace();
4479 register_node_type_cmp_mapuv();
4480 register_node_type_cmp_glare();
4481 register_node_type_cmp_tonemap();
4482 register_node_type_cmp_lensdist();
4483 register_node_type_cmp_transform();
4484 register_node_type_cmp_stabilize2d();
4485 register_node_type_cmp_moviedistortion();
4486
4487 register_node_type_cmp_colorcorrection();
4488 register_node_type_cmp_boxmask();
4489 register_node_type_cmp_ellipsemask();
4490 register_node_type_cmp_bokehimage();
4491 register_node_type_cmp_bokehblur();
4492 register_node_type_cmp_switch();
4493 register_node_type_cmp_switch_view();
4494 register_node_type_cmp_pixelate();
4495
4496 register_node_type_cmp_mask();
4497 register_node_type_cmp_trackpos();
4498 register_node_type_cmp_planetrackdeform();
4499 register_node_type_cmp_cornerpin();
4500 }
4501
registerShaderNodes(void)4502 static void registerShaderNodes(void)
4503 {
4504 register_node_type_sh_group();
4505
4506 register_node_type_sh_camera();
4507 register_node_type_sh_gamma();
4508 register_node_type_sh_brightcontrast();
4509 register_node_type_sh_value();
4510 register_node_type_sh_rgb();
4511 register_node_type_sh_wireframe();
4512 register_node_type_sh_wavelength();
4513 register_node_type_sh_blackbody();
4514 register_node_type_sh_mix_rgb();
4515 register_node_type_sh_valtorgb();
4516 register_node_type_sh_rgbtobw();
4517 register_node_type_sh_shadertorgb();
4518 register_node_type_sh_normal();
4519 register_node_type_sh_mapping();
4520 register_node_type_sh_curve_vec();
4521 register_node_type_sh_curve_rgb();
4522 register_node_type_sh_map_range();
4523 register_node_type_sh_clamp();
4524 register_node_type_sh_math();
4525 register_node_type_sh_vect_math();
4526 register_node_type_sh_vector_rotate();
4527 register_node_type_sh_vect_transform();
4528 register_node_type_sh_squeeze();
4529 register_node_type_sh_invert();
4530 register_node_type_sh_seprgb();
4531 register_node_type_sh_combrgb();
4532 register_node_type_sh_sephsv();
4533 register_node_type_sh_combhsv();
4534 register_node_type_sh_sepxyz();
4535 register_node_type_sh_combxyz();
4536 register_node_type_sh_hue_sat();
4537
4538 register_node_type_sh_attribute();
4539 register_node_type_sh_bevel();
4540 register_node_type_sh_displacement();
4541 register_node_type_sh_vector_displacement();
4542 register_node_type_sh_geometry();
4543 register_node_type_sh_light_path();
4544 register_node_type_sh_light_falloff();
4545 register_node_type_sh_object_info();
4546 register_node_type_sh_fresnel();
4547 register_node_type_sh_layer_weight();
4548 register_node_type_sh_tex_coord();
4549 register_node_type_sh_particle_info();
4550 register_node_type_sh_bump();
4551 register_node_type_sh_vertex_color();
4552
4553 register_node_type_sh_background();
4554 register_node_type_sh_bsdf_anisotropic();
4555 register_node_type_sh_bsdf_diffuse();
4556 register_node_type_sh_bsdf_principled();
4557 register_node_type_sh_bsdf_glossy();
4558 register_node_type_sh_bsdf_glass();
4559 register_node_type_sh_bsdf_translucent();
4560 register_node_type_sh_bsdf_transparent();
4561 register_node_type_sh_bsdf_velvet();
4562 register_node_type_sh_bsdf_toon();
4563 register_node_type_sh_bsdf_hair();
4564 register_node_type_sh_bsdf_hair_principled();
4565 register_node_type_sh_emission();
4566 register_node_type_sh_holdout();
4567 register_node_type_sh_volume_absorption();
4568 register_node_type_sh_volume_scatter();
4569 register_node_type_sh_volume_principled();
4570 register_node_type_sh_subsurface_scattering();
4571 register_node_type_sh_mix_shader();
4572 register_node_type_sh_add_shader();
4573 register_node_type_sh_uvmap();
4574 register_node_type_sh_uvalongstroke();
4575 register_node_type_sh_eevee_specular();
4576
4577 register_node_type_sh_output_light();
4578 register_node_type_sh_output_material();
4579 register_node_type_sh_output_world();
4580 register_node_type_sh_output_linestyle();
4581 register_node_type_sh_output_aov();
4582
4583 register_node_type_sh_tex_image();
4584 register_node_type_sh_tex_environment();
4585 register_node_type_sh_tex_sky();
4586 register_node_type_sh_tex_noise();
4587 register_node_type_sh_tex_wave();
4588 register_node_type_sh_tex_voronoi();
4589 register_node_type_sh_tex_musgrave();
4590 register_node_type_sh_tex_gradient();
4591 register_node_type_sh_tex_magic();
4592 register_node_type_sh_tex_checker();
4593 register_node_type_sh_tex_brick();
4594 register_node_type_sh_tex_pointdensity();
4595 register_node_type_sh_tex_ies();
4596 register_node_type_sh_tex_white_noise();
4597 }
4598
registerTextureNodes(void)4599 static void registerTextureNodes(void)
4600 {
4601 register_node_type_tex_group();
4602
4603 register_node_type_tex_math();
4604 register_node_type_tex_mix_rgb();
4605 register_node_type_tex_valtorgb();
4606 register_node_type_tex_rgbtobw();
4607 register_node_type_tex_valtonor();
4608 register_node_type_tex_curve_rgb();
4609 register_node_type_tex_curve_time();
4610 register_node_type_tex_invert();
4611 register_node_type_tex_hue_sat();
4612 register_node_type_tex_coord();
4613 register_node_type_tex_distance();
4614 register_node_type_tex_compose();
4615 register_node_type_tex_decompose();
4616
4617 register_node_type_tex_output();
4618 register_node_type_tex_viewer();
4619 register_node_type_sh_script();
4620 register_node_type_sh_tangent();
4621 register_node_type_sh_normal_map();
4622 register_node_type_sh_hair_info();
4623 register_node_type_sh_volume_info();
4624
4625 register_node_type_tex_checker();
4626 register_node_type_tex_texture();
4627 register_node_type_tex_bricks();
4628 register_node_type_tex_image();
4629 register_node_type_sh_bsdf_refraction();
4630 register_node_type_sh_ambient_occlusion();
4631
4632 register_node_type_tex_rotate();
4633 register_node_type_tex_translate();
4634 register_node_type_tex_scale();
4635 register_node_type_tex_at();
4636
4637 register_node_type_tex_proc_voronoi();
4638 register_node_type_tex_proc_blend();
4639 register_node_type_tex_proc_magic();
4640 register_node_type_tex_proc_marble();
4641 register_node_type_tex_proc_clouds();
4642 register_node_type_tex_proc_wood();
4643 register_node_type_tex_proc_musgrave();
4644 register_node_type_tex_proc_noise();
4645 register_node_type_tex_proc_stucci();
4646 register_node_type_tex_proc_distnoise();
4647 }
4648
registerSimulationNodes(void)4649 static void registerSimulationNodes(void)
4650 {
4651 register_node_type_sim_group();
4652 }
4653
registerFunctionNodes(void)4654 static void registerFunctionNodes(void)
4655 {
4656 register_node_type_fn_boolean_math();
4657 register_node_type_fn_float_compare();
4658 register_node_type_fn_switch();
4659 register_node_type_fn_group_instance_id();
4660 register_node_type_fn_combine_strings();
4661 register_node_type_fn_object_transforms();
4662 register_node_type_fn_random_float();
4663 }
4664
init_nodesystem(void)4665 void init_nodesystem(void)
4666 {
4667 nodetreetypes_hash = BLI_ghash_str_new("nodetreetypes_hash gh");
4668 nodetypes_hash = BLI_ghash_str_new("nodetypes_hash gh");
4669 nodesockettypes_hash = BLI_ghash_str_new("nodesockettypes_hash gh");
4670
4671 register_undefined_types();
4672
4673 register_standard_node_socket_types();
4674
4675 register_node_tree_type_cmp();
4676 register_node_tree_type_sh();
4677 register_node_tree_type_tex();
4678 register_node_tree_type_sim();
4679
4680 register_node_type_frame();
4681 register_node_type_reroute();
4682 register_node_type_group_input();
4683 register_node_type_group_output();
4684
4685 registerCompositNodes();
4686 registerShaderNodes();
4687 registerTextureNodes();
4688 registerSimulationNodes();
4689 registerFunctionNodes();
4690 }
4691
free_nodesystem(void)4692 void free_nodesystem(void)
4693 {
4694 if (nodetypes_hash) {
4695 NODE_TYPES_BEGIN (nt) {
4696 if (nt->rna_ext.free) {
4697 nt->rna_ext.free(nt->rna_ext.data);
4698 }
4699 }
4700 NODE_TYPES_END;
4701
4702 BLI_ghash_free(nodetypes_hash, NULL, node_free_type);
4703 nodetypes_hash = NULL;
4704 }
4705
4706 if (nodesockettypes_hash) {
4707 NODE_SOCKET_TYPES_BEGIN (st) {
4708 if (st->ext_socket.free) {
4709 st->ext_socket.free(st->ext_socket.data);
4710 }
4711 if (st->ext_interface.free) {
4712 st->ext_interface.free(st->ext_interface.data);
4713 }
4714 }
4715 NODE_SOCKET_TYPES_END;
4716
4717 BLI_ghash_free(nodesockettypes_hash, NULL, node_free_socket_type);
4718 nodesockettypes_hash = NULL;
4719 }
4720
4721 if (nodetreetypes_hash) {
4722 NODE_TREE_TYPES_BEGIN (nt) {
4723 if (nt->rna_ext.free) {
4724 nt->rna_ext.free(nt->rna_ext.data);
4725 }
4726 }
4727 NODE_TREE_TYPES_END;
4728
4729 BLI_ghash_free(nodetreetypes_hash, NULL, ntree_free_type);
4730 nodetreetypes_hash = NULL;
4731 }
4732 }
4733
4734 /* -------------------------------------------------------------------- */
4735 /* NodeTree Iterator Helpers (FOREACH_NODETREE_BEGIN) */
4736
BKE_node_tree_iter_init(struct NodeTreeIterStore * ntreeiter,struct Main * bmain)4737 void BKE_node_tree_iter_init(struct NodeTreeIterStore *ntreeiter, struct Main *bmain)
4738 {
4739 ntreeiter->ngroup = bmain->nodetrees.first;
4740 ntreeiter->scene = bmain->scenes.first;
4741 ntreeiter->mat = bmain->materials.first;
4742 ntreeiter->tex = bmain->textures.first;
4743 ntreeiter->light = bmain->lights.first;
4744 ntreeiter->world = bmain->worlds.first;
4745 ntreeiter->linestyle = bmain->linestyles.first;
4746 ntreeiter->simulation = bmain->simulations.first;
4747 }
BKE_node_tree_iter_step(struct NodeTreeIterStore * ntreeiter,bNodeTree ** r_nodetree,struct ID ** r_id)4748 bool BKE_node_tree_iter_step(struct NodeTreeIterStore *ntreeiter,
4749 bNodeTree **r_nodetree,
4750 struct ID **r_id)
4751 {
4752 if (ntreeiter->ngroup) {
4753 *r_nodetree = ntreeiter->ngroup;
4754 *r_id = (ID *)ntreeiter->ngroup;
4755 ntreeiter->ngroup = ntreeiter->ngroup->id.next;
4756 }
4757 else if (ntreeiter->scene) {
4758 *r_nodetree = ntreeiter->scene->nodetree;
4759 *r_id = (ID *)ntreeiter->scene;
4760 ntreeiter->scene = ntreeiter->scene->id.next;
4761 }
4762 else if (ntreeiter->mat) {
4763 *r_nodetree = ntreeiter->mat->nodetree;
4764 *r_id = (ID *)ntreeiter->mat;
4765 ntreeiter->mat = ntreeiter->mat->id.next;
4766 }
4767 else if (ntreeiter->tex) {
4768 *r_nodetree = ntreeiter->tex->nodetree;
4769 *r_id = (ID *)ntreeiter->tex;
4770 ntreeiter->tex = ntreeiter->tex->id.next;
4771 }
4772 else if (ntreeiter->light) {
4773 *r_nodetree = ntreeiter->light->nodetree;
4774 *r_id = (ID *)ntreeiter->light;
4775 ntreeiter->light = ntreeiter->light->id.next;
4776 }
4777 else if (ntreeiter->world) {
4778 *r_nodetree = ntreeiter->world->nodetree;
4779 *r_id = (ID *)ntreeiter->world;
4780 ntreeiter->world = ntreeiter->world->id.next;
4781 }
4782 else if (ntreeiter->linestyle) {
4783 *r_nodetree = ntreeiter->linestyle->nodetree;
4784 *r_id = (ID *)ntreeiter->linestyle;
4785 ntreeiter->linestyle = ntreeiter->linestyle->id.next;
4786 }
4787 else if (ntreeiter->simulation) {
4788 *r_nodetree = ntreeiter->simulation->nodetree;
4789 *r_id = (ID *)ntreeiter->simulation;
4790 ntreeiter->simulation = ntreeiter->simulation->id.next;
4791 }
4792 else {
4793 return false;
4794 }
4795
4796 return true;
4797 }
4798
4799 /* -------------------------------------------------------------------- */
4800 /* NodeTree kernel functions */
4801
BKE_nodetree_remove_layer_n(bNodeTree * ntree,Scene * scene,const int layer_index)4802 void BKE_nodetree_remove_layer_n(bNodeTree *ntree, Scene *scene, const int layer_index)
4803 {
4804 BLI_assert(layer_index != -1);
4805 LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
4806 if (node->type == CMP_NODE_R_LAYERS && (Scene *)node->id == scene) {
4807 if (node->custom1 == layer_index) {
4808 node->custom1 = 0;
4809 }
4810 else if (node->custom1 > layer_index) {
4811 node->custom1--;
4812 }
4813 }
4814 }
4815 }
4816
BKE_nodetree_shading_params_eval(struct Depsgraph * depsgraph,bNodeTree * ntree_dst,const bNodeTree * ntree_src)4817 void BKE_nodetree_shading_params_eval(struct Depsgraph *depsgraph,
4818 bNodeTree *ntree_dst,
4819 const bNodeTree *ntree_src)
4820 {
4821 DEG_debug_print_eval(depsgraph, __func__, ntree_src->id.name, ntree_dst);
4822 }
4823