Blender  V3.3
node_socket.cc
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2007 Blender Foundation. All rights reserved. */
3 
8 #include <climits>
9 
10 #include "DNA_node_types.h"
11 
12 #include "BLI_color.hh"
13 #include "BLI_cpp_type_make.hh"
14 #include "BLI_listbase.h"
15 #include "BLI_math_vec_types.hh"
16 #include "BLI_string.h"
17 #include "BLI_utildefines.h"
18 
19 #include "BKE_geometry_set.hh"
20 #include "BKE_lib_id.h"
21 #include "BKE_node.h"
22 #include "BKE_node_runtime.hh"
23 
24 #include "DNA_collection_types.h"
25 #include "DNA_material_types.h"
26 
27 #include "RNA_access.h"
28 #include "RNA_types.h"
29 
30 #include "MEM_guardedalloc.h"
31 
32 #include "NOD_node_declaration.hh"
33 #include "NOD_socket.h"
34 
35 #include "FN_field.hh"
36 
37 using namespace blender;
40 
42  struct bNode *node,
43  struct bNodeSocketTemplate *stemp,
45 {
47  ntree, node, in_out, stemp->type, stemp->subtype, stemp->identifier, stemp->name);
48 
49  sock->flag |= stemp->flag;
50 
51  /* initialize default_value */
52  switch (stemp->type) {
53  case SOCK_FLOAT: {
55  dval->value = stemp->val1;
56  dval->min = stemp->min;
57  dval->max = stemp->max;
58  break;
59  }
60  case SOCK_INT: {
62  dval->value = (int)stemp->val1;
63  dval->min = (int)stemp->min;
64  dval->max = (int)stemp->max;
65  break;
66  }
67  case SOCK_BOOLEAN: {
69  dval->value = (int)stemp->val1;
70  break;
71  }
72  case SOCK_VECTOR: {
74  dval->value[0] = stemp->val1;
75  dval->value[1] = stemp->val2;
76  dval->value[2] = stemp->val3;
77  dval->min = stemp->min;
78  dval->max = stemp->max;
79  break;
80  }
81  case SOCK_RGBA: {
83  dval->value[0] = stemp->val1;
84  dval->value[1] = stemp->val2;
85  dval->value[2] = stemp->val3;
86  dval->value[3] = stemp->val4;
87  break;
88  }
89  }
90 
91  return sock;
92 }
93 
95  bNode *node,
97  ListBase *socklist,
98  bNodeSocketTemplate *stemp)
99 {
100  bNodeSocket *sock;
101 
102  for (sock = (bNodeSocket *)socklist->first; sock; sock = sock->next) {
103  if (STREQLEN(sock->name, stemp->name, NODE_MAXSTR)) {
104  break;
105  }
106  }
107  if (sock) {
108  if (sock->type != stemp->type) {
109  nodeModifySocketTypeStatic(ntree, node, sock, stemp->type, stemp->subtype);
110  }
111  sock->flag |= stemp->flag;
112  }
113  else {
114  /* no socket for this template found, make a new one */
116  }
117 
118  /* remove the new socket from the node socket list first,
119  * will be added back after verification. */
120  BLI_remlink(socklist, sock);
121 
122  return sock;
123 }
124 
126  bNode *node,
128  ListBase *socklist,
129  bNodeSocketTemplate *stemp_first)
130 {
131  bNodeSocket *sock, *nextsock;
132  bNodeSocketTemplate *stemp;
133 
134  /* no inputs anymore? */
135  if (stemp_first == nullptr) {
136  for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) {
137  nextsock = sock->next;
138  nodeRemoveSocket(ntree, node, sock);
139  }
140  }
141  else {
142  /* step by step compare */
143  stemp = stemp_first;
144  while (stemp->type != -1) {
145  stemp->sock = verify_socket_template(ntree, node, in_out, socklist, stemp);
146  stemp++;
147  }
148  /* leftovers are removed */
149  for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) {
150  nextsock = sock->next;
151  nodeRemoveSocket(ntree, node, sock);
152  }
153 
154  /* and we put back the verified sockets */
155  stemp = stemp_first;
156  if (socklist->first) {
157  /* Some dynamic sockets left, store the list start
158  * so we can add static sockets in front of it. */
159  sock = (bNodeSocket *)socklist->first;
160  while (stemp->type != -1) {
161  /* Put static sockets in front of dynamic. */
162  BLI_insertlinkbefore(socklist, sock, stemp->sock);
163  stemp++;
164  }
165  }
166  else {
167  while (stemp->type != -1) {
168  BLI_addtail(socklist, stemp->sock);
169  stemp++;
170  }
171  }
172  }
173 }
174 
176  bNode &node,
177  ListBase &sockets,
178  Span<SocketDeclarationPtr> socket_decls,
179  const bool do_id_user)
180 {
181  Vector<bNodeSocket *> old_sockets = sockets;
182  VectorSet<bNodeSocket *> new_sockets;
183  for (const SocketDeclarationPtr &socket_decl : socket_decls) {
184  /* Try to find a socket that corresponds to the declaration. */
185  bNodeSocket *old_socket_with_same_identifier = nullptr;
186  for (const int i : old_sockets.index_range()) {
187  bNodeSocket &old_socket = *old_sockets[i];
188  if (old_socket.identifier == socket_decl->identifier()) {
189  old_sockets.remove_and_reorder(i);
190  old_socket_with_same_identifier = &old_socket;
191  break;
192  }
193  }
194  bNodeSocket *new_socket = nullptr;
195  if (old_socket_with_same_identifier == nullptr) {
196  /* Create a completely new socket. */
197  new_socket = &socket_decl->build(ntree, node);
198  }
199  else {
200  STRNCPY(old_socket_with_same_identifier->name, socket_decl->name().c_str());
201  if (socket_decl->matches(*old_socket_with_same_identifier)) {
202  /* The existing socket matches exactly, just use it. */
203  new_socket = old_socket_with_same_identifier;
204  }
205  else {
206  /* Clear out identifier to avoid name collisions when a new socket is created. */
207  old_socket_with_same_identifier->identifier[0] = '\0';
208  new_socket = &socket_decl->update_or_build(ntree, node, *old_socket_with_same_identifier);
209 
210  if (new_socket == old_socket_with_same_identifier) {
211  /* The existing socket has been updated, set the correct identifier again. */
212  STRNCPY(new_socket->identifier, socket_decl->identifier().c_str());
213  }
214  else {
215  /* Move links to new socket with same identifier. */
217  if (link->fromsock == old_socket_with_same_identifier) {
218  link->fromsock = new_socket;
219  }
220  else if (link->tosock == old_socket_with_same_identifier) {
221  link->tosock = new_socket;
222  }
223  }
224  LISTBASE_FOREACH (bNodeLink *, internal_link, &node.internal_links) {
225  if (internal_link->fromsock == old_socket_with_same_identifier) {
226  internal_link->fromsock = new_socket;
227  }
228  else if (internal_link->tosock == old_socket_with_same_identifier) {
229  internal_link->tosock = new_socket;
230  }
231  }
232  }
233  }
234  }
235  new_sockets.add_new(new_socket);
236  }
237  LISTBASE_FOREACH_MUTABLE (bNodeSocket *, old_socket, &sockets) {
238  if (!new_sockets.contains(old_socket)) {
239  nodeRemoveSocketEx(&ntree, &node, old_socket, do_id_user);
240  }
241  }
242  BLI_listbase_clear(&sockets);
243  for (bNodeSocket *socket : new_sockets) {
244  BLI_addtail(&sockets, socket);
245  }
246 }
247 
249  bNode &node,
251  bool do_id_user)
252 {
253  refresh_socket_list(ntree, node, node.inputs, node_decl.inputs(), do_id_user);
254  refresh_socket_list(ntree, node, node.outputs, node_decl.outputs(), do_id_user);
255 }
256 
257 void node_verify_sockets(bNodeTree *ntree, bNode *node, bool do_id_user)
258 {
259  bNodeType *ntype = node->typeinfo;
260  if (ntype == nullptr) {
261  return;
262  }
263  if (ntype->declare != nullptr) {
265  if (!node->runtime->declaration->matches(*node)) {
266  refresh_node(*ntree, *node, *node->runtime->declaration, do_id_user);
267  }
269  return;
270  }
271  /* Don't try to match socket lists when there are no templates.
272  * This prevents dynamically generated sockets to be removed, like for
273  * group, image or render layer nodes. We have an explicit check for the
274  * render layer node since it still has fixed sockets too.
275  */
276  if (ntype) {
277  if (ntype->inputs && ntype->inputs[0].type >= 0) {
279  }
280  if (ntype->outputs && ntype->outputs[0].type >= 0 && node->type != CMP_NODE_R_LAYERS) {
282  }
283  }
284 }
285 
287 {
288  int type = sock->typeinfo->type;
289  int subtype = sock->typeinfo->subtype;
290 
291  if (sock->default_value) {
292  return; /* already initialized */
293  }
294 
295  switch (type) {
296  case SOCK_FLOAT: {
297  bNodeSocketValueFloat *dval = MEM_cnew<bNodeSocketValueFloat>("node socket value float");
298  dval->subtype = subtype;
299  dval->value = 0.0f;
300  dval->min = -FLT_MAX;
301  dval->max = FLT_MAX;
302 
303  sock->default_value = dval;
304  break;
305  }
306  case SOCK_INT: {
307  bNodeSocketValueInt *dval = MEM_cnew<bNodeSocketValueInt>("node socket value int");
308  dval->subtype = subtype;
309  dval->value = 0;
310  dval->min = INT_MIN;
311  dval->max = INT_MAX;
312 
313  sock->default_value = dval;
314  break;
315  }
316  case SOCK_BOOLEAN: {
317  bNodeSocketValueBoolean *dval = MEM_cnew<bNodeSocketValueBoolean>("node socket value bool");
318  dval->value = false;
319 
320  sock->default_value = dval;
321  break;
322  }
323  case SOCK_VECTOR: {
324  static float default_value[] = {0.0f, 0.0f, 0.0f};
325  bNodeSocketValueVector *dval = MEM_cnew<bNodeSocketValueVector>("node socket value vector");
326  dval->subtype = subtype;
328  dval->min = -FLT_MAX;
329  dval->max = FLT_MAX;
330 
331  sock->default_value = dval;
332  break;
333  }
334  case SOCK_RGBA: {
335  static float default_value[] = {0.0f, 0.0f, 0.0f, 1.0f};
336  bNodeSocketValueRGBA *dval = MEM_cnew<bNodeSocketValueRGBA>("node socket value color");
338 
339  sock->default_value = dval;
340  break;
341  }
342  case SOCK_STRING: {
343  bNodeSocketValueString *dval = MEM_cnew<bNodeSocketValueString>("node socket value string");
344  dval->subtype = subtype;
345  dval->value[0] = '\0';
346 
347  sock->default_value = dval;
348  break;
349  }
350  case SOCK_OBJECT: {
351  bNodeSocketValueObject *dval = MEM_cnew<bNodeSocketValueObject>("node socket value object");
352  dval->value = nullptr;
353 
354  sock->default_value = dval;
355  break;
356  }
357  case SOCK_IMAGE: {
358  bNodeSocketValueImage *dval = MEM_cnew<bNodeSocketValueImage>("node socket value image");
359  dval->value = nullptr;
360 
361  sock->default_value = dval;
362  break;
363  }
364  case SOCK_COLLECTION: {
365  bNodeSocketValueCollection *dval = MEM_cnew<bNodeSocketValueCollection>(
366  "node socket value object");
367  dval->value = nullptr;
368 
369  sock->default_value = dval;
370  break;
371  }
372  case SOCK_TEXTURE: {
373  bNodeSocketValueTexture *dval = MEM_cnew<bNodeSocketValueTexture>(
374  "node socket value texture");
375  dval->value = nullptr;
376 
377  sock->default_value = dval;
378  break;
379  }
380  case SOCK_MATERIAL: {
381  bNodeSocketValueMaterial *dval = MEM_cnew<bNodeSocketValueMaterial>(
382  "node socket value material");
383  dval->value = nullptr;
384 
385  sock->default_value = dval;
386  break;
387  }
388  }
389 }
390 
392 {
393  /* sanity check */
394  if (to->type != from->type) {
395  return;
396  }
397 
398  /* make sure both exist */
399  if (!from->default_value) {
400  return;
401  }
403 
404  /* use label instead of name if it has been set */
405  if (from->label[0] != '\0') {
406  BLI_strncpy(to->name, from->label, NODE_MAXSTR);
407  }
408 
409  switch (from->typeinfo->type) {
410  case SOCK_FLOAT: {
412  bNodeSocketValueFloat *fromval = (bNodeSocketValueFloat *)from->default_value;
413  *toval = *fromval;
414  break;
415  }
416  case SOCK_INT: {
418  bNodeSocketValueInt *fromval = (bNodeSocketValueInt *)from->default_value;
419  *toval = *fromval;
420  break;
421  }
422  case SOCK_BOOLEAN: {
424  bNodeSocketValueBoolean *fromval = (bNodeSocketValueBoolean *)from->default_value;
425  *toval = *fromval;
426  break;
427  }
428  case SOCK_VECTOR: {
430  bNodeSocketValueVector *fromval = (bNodeSocketValueVector *)from->default_value;
431  *toval = *fromval;
432  break;
433  }
434  case SOCK_RGBA: {
436  bNodeSocketValueRGBA *fromval = (bNodeSocketValueRGBA *)from->default_value;
437  *toval = *fromval;
438  break;
439  }
440  case SOCK_STRING: {
442  bNodeSocketValueString *fromval = (bNodeSocketValueString *)from->default_value;
443  *toval = *fromval;
444  break;
445  }
446  case SOCK_OBJECT: {
448  bNodeSocketValueObject *fromval = (bNodeSocketValueObject *)from->default_value;
449  *toval = *fromval;
450  id_us_plus(&toval->value->id);
451  break;
452  }
453  case SOCK_IMAGE: {
455  bNodeSocketValueImage *fromval = (bNodeSocketValueImage *)from->default_value;
456  *toval = *fromval;
457  id_us_plus(&toval->value->id);
458  break;
459  }
460  case SOCK_COLLECTION: {
462  bNodeSocketValueCollection *fromval = (bNodeSocketValueCollection *)from->default_value;
463  *toval = *fromval;
464  id_us_plus(&toval->value->id);
465  break;
466  }
467  case SOCK_TEXTURE: {
469  bNodeSocketValueTexture *fromval = (bNodeSocketValueTexture *)from->default_value;
470  *toval = *fromval;
471  id_us_plus(&toval->value->id);
472  break;
473  }
474  case SOCK_MATERIAL: {
476  bNodeSocketValueMaterial *fromval = (bNodeSocketValueMaterial *)from->default_value;
477  *toval = *fromval;
478  id_us_plus(&toval->value->id);
479  break;
480  }
481  }
482 
483  to->flag |= (from->flag & SOCK_HIDE_VALUE);
484 }
485 
487  ListBase *links, bNode *node, bNodeSocket *socket, bNode **r_node, bNodeSocket **r_socket)
488 {
489  const int loop_limit = 100; /* Limit in case there is a connection cycle. */
490 
491  if (socket->in_out == SOCK_IN) {
492  bNodeLink *first_link = (bNodeLink *)links->first;
493 
494  for (int i = 0; node->type == NODE_REROUTE && i < loop_limit; i++) {
495  bNodeLink *link = first_link;
496 
497  for (; link; link = link->next) {
498  if (link->fromnode == node && link->tonode != node) {
499  break;
500  }
501  }
502 
503  if (link) {
504  node = link->tonode;
505  socket = link->tosock;
506  }
507  else {
508  break;
509  }
510  }
511  }
512  else {
513  for (int i = 0; node->type == NODE_REROUTE && i < loop_limit; i++) {
514  bNodeSocket *input = (bNodeSocket *)node->inputs.first;
515 
516  if (input && input->link) {
517  node = input->link->fromnode;
518  socket = input->link->fromsock;
519  }
520  else {
521  break;
522  }
523  }
524  }
525 
526  if (r_node) {
527  *r_node = node;
528  }
529  if (r_socket) {
530  *r_socket = socket;
531  }
532 }
533 
535  const bNodeSocket *interface_socket,
536  bNode *UNUSED(node),
537  bNodeSocket *sock,
538  const char *UNUSED(data_path))
539 {
540  /* initialize the type value */
541  sock->type = sock->typeinfo->type;
542 
543  /* XXX socket interface 'type' value is not used really,
544  * but has to match or the copy function will bail out
545  */
546  const_cast<bNodeSocket *>(interface_socket)->type = interface_socket->typeinfo->type;
547  /* copy default_value settings */
548  node_socket_copy_default_value(sock, interface_socket);
549 }
550 
551 /* copies settings that are not changed for each socket instance */
553  const bNodeSocket *interface_socket,
554  bNode *UNUSED(node),
555  bNodeSocket *sock,
556  const char *UNUSED(data_path))
557 {
558  /* sanity check */
559  if (sock->type != interface_socket->typeinfo->type) {
560  return;
561  }
562 
563  /* make sure both exist */
564  if (!interface_socket->default_value) {
565  return;
566  }
568 
569  switch (interface_socket->typeinfo->type) {
570  case SOCK_FLOAT: {
572  const bNodeSocketValueFloat *fromval = (const bNodeSocketValueFloat *)
573  interface_socket->default_value;
574  toval->min = fromval->min;
575  toval->max = fromval->max;
576  break;
577  }
578  case SOCK_INT: {
580  const bNodeSocketValueInt *fromval = (const bNodeSocketValueInt *)
581  interface_socket->default_value;
582  toval->min = fromval->min;
583  toval->max = fromval->max;
584  break;
585  }
586  case SOCK_VECTOR: {
588  const bNodeSocketValueVector *fromval = (const bNodeSocketValueVector *)
589  interface_socket->default_value;
590  toval->min = fromval->min;
591  toval->max = fromval->max;
592  break;
593  }
594  }
595 }
596 
598  bNodeSocket *stemp,
599  bNode *UNUSED(node),
600  bNodeSocket *sock)
601 {
602  /* initialize settings */
603  stemp->type = stemp->typeinfo->type;
604  node_socket_copy_default_value(stemp, sock);
605 }
606 
608 
610 {
611  const char *socket_idname = nodeStaticSocketType(type, subtype);
612  const char *interface_idname = nodeStaticSocketInterfaceType(type, subtype);
613  const char *socket_label = nodeStaticSocketLabel(type, subtype);
614  bNodeSocketType *stype;
615  StructRNA *srna;
616 
617  stype = MEM_cnew<bNodeSocketType>("node socket C type");
618  stype->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
619  BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname));
620  BLI_strncpy(stype->label, socket_label, sizeof(stype->label));
621 
622  /* set the RNA type
623  * uses the exact same identifier as the socket type idname */
624  srna = stype->ext_socket.srna = RNA_struct_find(socket_idname);
625  BLI_assert(srna != nullptr);
626  /* associate the RNA type with the socket type */
627  RNA_struct_blender_type_set(srna, stype);
628 
629  /* set the interface RNA type */
630  srna = stype->ext_interface.srna = RNA_struct_find(interface_idname);
631  BLI_assert(srna != nullptr);
632  /* associate the RNA type with the socket type */
633  RNA_struct_blender_type_set(srna, stype);
634 
635  /* extra type info for standard socket types */
636  stype->type = type;
637  stype->subtype = subtype;
638 
639  /* XXX bad-level call! needed for setting draw callbacks */
641 
645 
646  stype->use_link_limits_of_type = true;
647  stype->input_link_limit = 1;
648  stype->output_link_limit = 0xFFF;
649 
650  return stype;
651 }
652 
654 
656 {
657  const char *socket_idname = "NodeSocketVirtual";
658  bNodeSocketType *stype;
659  StructRNA *srna;
660 
661  stype = MEM_cnew<bNodeSocketType>("node socket C type");
662  stype->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
663  BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname));
664 
665  /* set the RNA type
666  * uses the exact same identifier as the socket type idname */
667  srna = stype->ext_socket.srna = RNA_struct_find(socket_idname);
668  BLI_assert(srna != nullptr);
669  /* associate the RNA type with the socket type */
670  RNA_struct_blender_type_set(srna, stype);
671 
672  /* extra type info for standard socket types */
673  stype->type = SOCK_CUSTOM;
674 
676 
677  stype->use_link_limits_of_type = true;
678  stype->input_link_limit = 0xFFF;
679  stype->output_link_limit = 0xFFF;
680 
681  return stype;
682 }
683 
685 {
687  socktype->base_cpp_type = &blender::CPPType::get<bool>();
688  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
689  *(bool *)r_value = ((bNodeSocketValueBoolean *)socket.default_value)->value;
690  };
691  socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<bool>>();
692  socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
693  bool value;
694  socket.typeinfo->get_base_cpp_value(socket, &value);
695  new (r_value) ValueOrField<bool>(value);
696  };
697  return socktype;
698 }
699 
701 {
703  socktype->base_cpp_type = &blender::CPPType::get<float>();
704  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
705  *(float *)r_value = ((bNodeSocketValueFloat *)socket.default_value)->value;
706  };
707  socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<float>>();
708  socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
709  float value;
710  socket.typeinfo->get_base_cpp_value(socket, &value);
711  new (r_value) ValueOrField<float>(value);
712  };
713  return socktype;
714 }
715 
717 {
718  bNodeSocketType *socktype = make_standard_socket_type(SOCK_INT, subtype);
719  socktype->base_cpp_type = &blender::CPPType::get<int>();
720  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
721  *(int *)r_value = ((bNodeSocketValueInt *)socket.default_value)->value;
722  };
723  socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<int>>();
724  socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
725  int value;
726  socket.typeinfo->get_base_cpp_value(socket, &value);
727  new (r_value) ValueOrField<int>(value);
728  };
729  return socktype;
730 }
731 
733 {
735  socktype->base_cpp_type = &blender::CPPType::get<blender::float3>();
736  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
737  *(blender::float3 *)r_value = ((bNodeSocketValueVector *)socket.default_value)->value;
738  };
739  socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<blender::float3>>();
740  socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
741  blender::float3 value;
742  socket.typeinfo->get_base_cpp_value(socket, &value);
743  new (r_value) ValueOrField<blender::float3>(value);
744  };
745  return socktype;
746 }
747 
749 {
751  socktype->base_cpp_type = &blender::CPPType::get<blender::ColorGeometry4f>();
752  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
753  *(blender::ColorGeometry4f *)r_value = ((bNodeSocketValueRGBA *)socket.default_value)->value;
754  };
755  socktype->geometry_nodes_cpp_type =
756  &blender::CPPType::get<ValueOrField<blender::ColorGeometry4f>>();
757  socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
759  socket.typeinfo->get_base_cpp_value(socket, &value);
760  new (r_value) ValueOrField<blender::ColorGeometry4f>(value);
761  };
762  return socktype;
763 }
764 
766 {
768  socktype->base_cpp_type = &blender::CPPType::get<std::string>();
769  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
770  new (r_value) std::string(((bNodeSocketValueString *)socket.default_value)->value);
771  };
772  socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<std::string>>();
773  socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
774  std::string value;
775  value.~basic_string();
776  socket.typeinfo->get_base_cpp_value(socket, &value);
777  new (r_value) ValueOrField<std::string>(value);
778  };
779  return socktype;
780 }
781 
787 
789 {
791  socktype->base_cpp_type = &blender::CPPType::get<Object *>();
792  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
793  *(Object **)r_value = ((bNodeSocketValueObject *)socket.default_value)->value;
794  };
795  socktype->geometry_nodes_cpp_type = socktype->base_cpp_type;
796  socktype->get_geometry_nodes_cpp_value = socktype->get_base_cpp_value;
797  return socktype;
798 }
799 
801 {
803  socktype->base_cpp_type = &blender::CPPType::get<GeometrySet>();
804  socktype->get_base_cpp_value = [](const bNodeSocket &UNUSED(socket), void *r_value) {
805  new (r_value) GeometrySet();
806  };
807  socktype->geometry_nodes_cpp_type = socktype->base_cpp_type;
808  socktype->get_geometry_nodes_cpp_value = socktype->get_base_cpp_value;
809  return socktype;
810 }
811 
813 {
815  socktype->base_cpp_type = &blender::CPPType::get<Collection *>();
816  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
817  *(Collection **)r_value = ((bNodeSocketValueCollection *)socket.default_value)->value;
818  };
819  socktype->geometry_nodes_cpp_type = socktype->base_cpp_type;
820  socktype->get_geometry_nodes_cpp_value = socktype->get_base_cpp_value;
821  return socktype;
822 }
823 
825 {
827  socktype->base_cpp_type = &blender::CPPType::get<Tex *>();
828  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
829  *(Tex **)r_value = ((bNodeSocketValueTexture *)socket.default_value)->value;
830  };
831  socktype->geometry_nodes_cpp_type = socktype->base_cpp_type;
832  socktype->get_geometry_nodes_cpp_value = socktype->get_base_cpp_value;
833  return socktype;
834 }
835 
837 {
839  socktype->base_cpp_type = &blender::CPPType::get<Image *>();
840  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
841  *(Image **)r_value = ((bNodeSocketValueImage *)socket.default_value)->value;
842  };
843  socktype->geometry_nodes_cpp_type = socktype->base_cpp_type;
844  socktype->get_geometry_nodes_cpp_value = socktype->get_base_cpp_value;
845  return socktype;
846 }
847 
849 {
851  socktype->base_cpp_type = &blender::CPPType::get<Material *>();
852  socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
853  *(Material **)r_value = ((bNodeSocketValueMaterial *)socket.default_value)->value;
854  };
855  socktype->geometry_nodes_cpp_type = socktype->base_cpp_type;
856  socktype->get_geometry_nodes_cpp_value = socktype->get_base_cpp_value;
857  return socktype;
858 }
859 
861 {
862  /* Draw callbacks are set in `drawnode.c` to avoid bad-level calls. */
863 
872 
877 
879 
887 
889 
891 
893 
895 
897 
899 
901 
903 
905 
907 }
void id_us_plus(struct ID *id)
Definition: lib_id.c:305
void nodeRemoveSocketEx(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, bool do_id_user)
Definition: node.cc:1938
#define NODE_REROUTE
Definition: BKE_node.h:986
void nodeRegisterSocketType(struct bNodeSocketType *stype)
Definition: node.cc:1419
void nodeSocketDeclarationsUpdate(struct bNode *node)
Definition: node.cc:3703
struct bNodeSocket * nodeAddStaticSocket(struct bNodeTree *ntree, struct bNode *node, eNodeSocketInOut in_out, int type, int subtype, const char *identifier, const char *name)
Definition: node.cc:1897
void nodeModifySocketTypeStatic(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, int type, int subtype)
Definition: node.cc:1666
const char * nodeStaticSocketLabel(int type, int subtype)
const char * nodeStaticSocketType(int type, int subtype)
Definition: node.cc:1710
const char * nodeStaticSocketInterfaceType(int type, int subtype)
Definition: node.cc:1787
void nodeRemoveSocket(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock)
Definition: node.cc:1933
bool nodeDeclarationEnsureOnOutdatedNode(struct bNodeTree *ntree, struct bNode *node)
#define CMP_NODE_R_LAYERS
Definition: BKE_node.h:1216
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
#define LISTBASE_FOREACH_MUTABLE(type, var, list)
Definition: BLI_listbase.h:354
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:100
void BLI_insertlinkbefore(struct ListBase *listbase, void *vnextlink, void *vnewlink) ATTR_NONNULL(1)
Definition: listbase.c:340
MINLINE void copy_v4_v4(float r[4], const float a[4])
MINLINE void copy_v3_v3(float r[3], const float a[3])
#define STRNCPY(dst, src)
Definition: BLI_string.h:483
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL()
Definition: string.c:64
#define STREQLEN(a, b, n)
#define UNUSED(x)
Object groups, one object can be in many groups at once.
#define NODE_MAXSTR
eNodeSocketInOut
@ SOCK_OUT
@ SOCK_IN
@ SOCK_HIDE_VALUE
@ SOCK_INT
@ SOCK_TEXTURE
@ SOCK_VECTOR
@ SOCK_BOOLEAN
@ SOCK_MATERIAL
@ SOCK_SHADER
@ SOCK_FLOAT
@ SOCK_IMAGE
@ SOCK_COLLECTION
@ SOCK_CUSTOM
@ SOCK_GEOMETRY
@ SOCK_OBJECT
@ SOCK_STRING
@ SOCK_RGBA
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
Read Guarded memory(de)allocation.
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Texture
PropertySubType
Definition: RNA_types.h:125
@ PROP_TIME
Definition: RNA_types.h:146
@ PROP_DIRECTION
Definition: RNA_types.h:155
@ PROP_XYZ
Definition: RNA_types.h:162
@ PROP_DISTANCE
Definition: RNA_types.h:149
@ PROP_ACCELERATION
Definition: RNA_types.h:157
@ PROP_ANGLE
Definition: RNA_types.h:145
@ PROP_TIME_ABSOLUTE
Definition: RNA_types.h:147
@ PROP_EULER
Definition: RNA_types.h:159
@ PROP_NONE
Definition: RNA_types.h:126
@ PROP_PERCENTAGE
Definition: RNA_types.h:143
@ PROP_FACTOR
Definition: RNA_types.h:144
@ PROP_TRANSLATION
Definition: RNA_types.h:154
@ PROP_UNSIGNED
Definition: RNA_types.h:142
@ PROP_VELOCITY
Definition: RNA_types.h:156
void add_new(const Key &key)
bool contains(const Key &key) const
void remove_and_reorder(const int64_t index)
Definition: BLI_vector.hh:743
IndexRange index_range() const
Definition: BLI_vector.hh:920
Span< SocketDeclarationPtr > outputs() const
Span< SocketDeclarationPtr > inputs() const
OperationNode * node
StackEntry * from
SyclQueue void void size_t num_bytes void
bNodeTree * ntree
BLI_CPP_TYPE_MAKE(GeometrySet, GeometrySet, CPPTypeFlags::Printable)
ccl_global KernelShaderEvalInput * input
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
std::unique_ptr< SocketDeclaration > SocketDeclarationPtr
void node_socket_init_default_value(bNodeSocket *sock)
Definition: node_socket.cc:286
static void standard_node_socket_interface_verify_socket(bNodeTree *UNUSED(ntree), const bNodeSocket *interface_socket, bNode *UNUSED(node), bNodeSocket *sock, const char *UNUSED(data_path))
Definition: node_socket.cc:552
void ED_init_node_socket_type_virtual(bNodeSocketType *)
Definition: drawnode.cc:1490
static void refresh_socket_list(bNodeTree &ntree, bNode &node, ListBase &sockets, Span< SocketDeclarationPtr > socket_decls, const bool do_id_user)
Definition: node_socket.cc:175
void node_socket_copy_default_value(bNodeSocket *to, const bNodeSocket *from)
Definition: node_socket.cc:391
static void standard_node_socket_interface_from_socket(bNodeTree *UNUSED(ntree), bNodeSocket *stemp, bNode *UNUSED(node), bNodeSocket *sock)
Definition: node_socket.cc:597
static void verify_socket_template_list(bNodeTree *ntree, bNode *node, eNodeSocketInOut in_out, ListBase *socklist, bNodeSocketTemplate *stemp_first)
Definition: node_socket.cc:125
static bNodeSocketType * make_socket_type_geometry()
Definition: node_socket.cc:800
static bNodeSocketType * make_socket_type_string()
Definition: node_socket.cc:765
static bNodeSocketType * make_socket_type_vector(PropertySubType subtype)
Definition: node_socket.cc:732
static bNodeSocketType * make_standard_socket_type(int type, int subtype)
Definition: node_socket.cc:609
static bNodeSocketType * make_socket_type_int(PropertySubType subtype)
Definition: node_socket.cc:716
static bNodeSocketType * make_socket_type_material()
Definition: node_socket.cc:848
static bNodeSocketType * make_socket_type_virtual()
Definition: node_socket.cc:655
static bNodeSocketType * make_socket_type_object()
Definition: node_socket.cc:788
static void standard_node_socket_interface_init_socket(bNodeTree *UNUSED(ntree), const bNodeSocket *interface_socket, bNode *UNUSED(node), bNodeSocket *sock, const char *UNUSED(data_path))
Definition: node_socket.cc:534
void ED_init_standard_node_socket_type(bNodeSocketType *)
Definition: drawnode.cc:1481
struct bNodeSocket * node_add_socket_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp, eNodeSocketInOut in_out)
Definition: node_socket.cc:41
void node_verify_sockets(bNodeTree *ntree, bNode *node, bool do_id_user)
Definition: node_socket.cc:257
static bNodeSocketType * make_socket_type_rgba()
Definition: node_socket.cc:748
static bNodeSocketType * make_socket_type_collection()
Definition: node_socket.cc:812
void register_standard_node_socket_types()
Definition: node_socket.cc:860
static bNodeSocketType * make_socket_type_texture()
Definition: node_socket.cc:824
void node_socket_skip_reroutes(ListBase *links, bNode *node, bNodeSocket *socket, bNode **r_node, bNodeSocket **r_socket)
Definition: node_socket.cc:486
static bNodeSocket * verify_socket_template(bNodeTree *ntree, bNode *node, eNodeSocketInOut in_out, ListBase *socklist, bNodeSocketTemplate *stemp)
Definition: node_socket.cc:94
static bNodeSocketType * make_socket_type_float(PropertySubType subtype)
Definition: node_socket.cc:700
static bNodeSocketType * make_socket_type_bool()
Definition: node_socket.cc:684
static void refresh_node(bNodeTree &ntree, bNode &node, blender::nodes::NodeDeclaration &node_decl, bool do_id_user)
Definition: node_socket.cc:248
static bNodeSocketType * make_socket_type_image()
Definition: node_socket.cc:836
void RNA_struct_blender_type_set(StructRNA *srna, void *blender_type)
Definition: rna_access.c:902
StructRNA * RNA_struct_find(const char *identifier)
Definition: rna_access.c:581
StructRNA * srna
Definition: RNA_types.h:766
void * first
Definition: DNA_listBase.h:31
Compact definition of a node socket.
Definition: BKE_node.h:84
struct bNodeSocket * sock
Definition: BKE_node.h:93
char identifier[64]
Definition: BKE_node.h:94
Defines a socket type.
Definition: BKE_node.h:143
SocketGetGeometryNodesCPPValueFunction get_geometry_nodes_cpp_value
Definition: BKE_node.h:201
char label[64]
Definition: BKE_node.h:147
void(* interface_from_socket)(struct bNodeTree *ntree, struct bNodeSocket *interface_socket, struct bNode *node, struct bNodeSocket *sock)
Definition: BKE_node.h:174
void(* interface_init_socket)(struct bNodeTree *ntree, const struct bNodeSocket *interface_socket, struct bNode *node, struct bNodeSocket *sock, const char *data_path)
Definition: BKE_node.h:164
const CPPTypeHandle * geometry_nodes_cpp_type
Definition: BKE_node.h:199
int input_link_limit
Definition: BKE_node.h:188
SocketGetCPPValueFunction get_base_cpp_value
Definition: BKE_node.h:197
ExtensionRNA ext_interface
Definition: BKE_node.h:181
ExtensionRNA ext_socket
Definition: BKE_node.h:180
int output_link_limit
Definition: BKE_node.h:189
const CPPTypeHandle * base_cpp_type
Definition: BKE_node.h:195
bool use_link_limits_of_type
Definition: BKE_node.h:187
void(* free_self)(struct bNodeSocketType *stype)
Definition: BKE_node.h:192
void(* interface_verify_socket)(struct bNodeTree *ntree, const struct bNodeSocket *interface_socket, struct bNode *node, struct bNodeSocket *sock, const char *data_path)
Definition: BKE_node.h:169
char idname[64]
Definition: BKE_node.h:145
struct Collection * value
struct Image * value
struct Material * value
struct Object * value
char name[64]
struct bNodeLink * link
struct bNodeSocket * next
void * default_value
struct bNodeSocketType * typeinfo
char identifier[64]
ListBase links
Defines a node type.
Definition: BKE_node.h:226
bNodeSocketTemplate * outputs
Definition: BKE_node.h:239
NodeDeclareFunction declare
Definition: BKE_node.h:324
bNodeSocketTemplate * inputs
Definition: BKE_node.h:239