source/blender/nodes/intern/node_socket.cc

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software Foundation,
  14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  15  *
  16  * The Original Code is Copyright (C) 2007 Blender Foundation.
  17  * All rights reserved.
  18  */
  19
  20 /** \file
  21  * \ingroup nodes
  22  */
  23
  24 #include <climits>
  25
  26 #include "DNA_node_types.h"
  27
  28 #include "BLI_color.hh"
  29 #include "BLI_float3.hh"
  30 #include "BLI_listbase.h"
  31 #include "BLI_math.h"
  32 #include "BLI_string.h"
  33 #include "BLI_utildefines.h"
  34
  35 #include "BKE_geometry_set.hh"
  36 #include "BKE_lib_id.h"
  37 #include "BKE_node.h"
  38 #include "BKE_persistent_data_handle.hh"
  39
  40 #include "DNA_collection_types.h"
  41
  42 #include "RNA_access.h"
  43 #include "RNA_types.h"
  44
  45 #include "MEM_guardedalloc.h"
  46
  47 #include "NOD_node_tree_multi_function.hh"
  48 #include "NOD_socket.h"
  49
  50 struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree,
  51                                                   struct bNode *node,
  52                                                   struct bNodeSocketTemplate *stemp,
  53                                                   int in_out)
  54 {
  55   bNodeSocket *sock = nodeAddStaticSocket(
  56       ntree, node, in_out, stemp->type, stemp->subtype, stemp->identifier, stemp->name);
  57
  58   sock->flag |= stemp->flag;
  59
  60   /* initialize default_value */
  61   switch (stemp->type) {
  62     case SOCK_FLOAT: {
  63       bNodeSocketValueFloat *dval = (bNodeSocketValueFloat *)sock->default_value;
  64       dval->value = stemp->val1;
  65       dval->min = stemp->min;
  66       dval->max = stemp->max;
  67       break;
  68     }
  69     case SOCK_INT: {
  70       bNodeSocketValueInt *dval = (bNodeSocketValueInt *)sock->default_value;
  71       dval->value = (int)stemp->val1;
  72       dval->min = (int)stemp->min;
  73       dval->max = (int)stemp->max;
  74       break;
  75     }
  76     case SOCK_BOOLEAN: {
  77       bNodeSocketValueBoolean *dval = (bNodeSocketValueBoolean *)sock->default_value;
  78       dval->value = (int)stemp->val1;
  79       break;
  80     }
  81     case SOCK_VECTOR: {
  82       bNodeSocketValueVector *dval = (bNodeSocketValueVector *)sock->default_value;
  83       dval->value[0] = stemp->val1;
  84       dval->value[1] = stemp->val2;
  85       dval->value[2] = stemp->val3;
  86       dval->min = stemp->min;
  87       dval->max = stemp->max;
  88       break;
  89     }
  90     case SOCK_RGBA: {
  91       bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA *)sock->default_value;
  92       dval->value[0] = stemp->val1;
  93       dval->value[1] = stemp->val2;
  94       dval->value[2] = stemp->val3;
  95       dval->value[3] = stemp->val4;
  96       break;
  97     }
  98   }
  99
 100   return sock;
 101 }
 102
 103 static bNodeSocket *verify_socket_template(
 104     bNodeTree *ntree, bNode *node, int in_out, ListBase *socklist, bNodeSocketTemplate *stemp)
 105 {
 106   bNodeSocket *sock;
 107
 108   for (sock = (bNodeSocket *)socklist->first; sock; sock = sock->next) {
 109     if (STREQLEN(sock->name, stemp->name, NODE_MAXSTR)) {
 110       break;
 111     }
 112   }
 113   if (sock) {
 114     if (sock->type != stemp->type) {
 115       nodeModifySocketType(ntree, node, sock, stemp->type, stemp->subtype);
 116     }
 117     sock->flag |= stemp->flag;
 118   }
 119   else {
 120     /* no socket for this template found, make a new one */
 121     sock = node_add_socket_from_template(ntree, node, stemp, in_out);
 122   }
 123
 124   /* remove the new socket from the node socket list first,
 125    * will be added back after verification. */
 126   BLI_remlink(socklist, sock);
 127
 128   return sock;
 129 }
 130
 131 static void verify_socket_template_list(bNodeTree *ntree,
 132                                         bNode *node,
 133                                         int in_out,
 134                                         ListBase *socklist,
 135                                         bNodeSocketTemplate *stemp_first)
 136 {
 137   bNodeSocket *sock, *nextsock;
 138   bNodeSocketTemplate *stemp;
 139
 140   /* no inputs anymore? */
 141   if (stemp_first == nullptr) {
 142     for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) {
 143       nextsock = sock->next;
 144       nodeRemoveSocket(ntree, node, sock);
 145     }
 146   }
 147   else {
 148     /* step by step compare */
 149     stemp = stemp_first;
 150     while (stemp->type != -1) {
 151       stemp->sock = verify_socket_template(ntree, node, in_out, socklist, stemp);
 152       stemp++;
 153     }
 154     /* leftovers are removed */
 155     for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) {
 156       nextsock = sock->next;
 157       nodeRemoveSocket(ntree, node, sock);
 158     }
 159
 160     /* and we put back the verified sockets */
 161     stemp = stemp_first;
 162     if (socklist->first) {
 163       /* Some dynamic sockets left, store the list start
 164        * so we can add static sockets in front of it. */
 165       sock = (bNodeSocket *)socklist->first;
 166       while (stemp->type != -1) {
 167         /* Put static sockets in front of dynamic. */
 168         BLI_insertlinkbefore(socklist, sock, stemp->sock);
 169         stemp++;
 170       }
 171     }
 172     else {
 173       while (stemp->type != -1) {
 174         BLI_addtail(socklist, stemp->sock);
 175         stemp++;
 176       }
 177     }
 178   }
 179 }
 180
 181 void node_verify_socket_templates(bNodeTree *ntree, bNode *node)
 182 {
 183   bNodeType *ntype = node->typeinfo;
 184   /* Don't try to match socket lists when there are no templates.
 185    * This prevents dynamically generated sockets to be removed, like for
 186    * group, image or render layer nodes. We have an explicit check for the
 187    * render layer node since it still has fixed sockets too.
 188    */
 189   if (ntype) {
 190     if (ntype->inputs && ntype->inputs[0].type >= 0) {
 191       verify_socket_template_list(ntree, node, SOCK_IN, &node->inputs, ntype->inputs);
 192     }
 193     if (ntype->outputs && ntype->outputs[0].type >= 0 && node->type != CMP_NODE_R_LAYERS) {
 194       verify_socket_template_list(ntree, node, SOCK_OUT, &node->outputs, ntype->outputs);
 195     }
 196   }
 197 }
 198
 199 void node_socket_init_default_value(bNodeSocket *sock)
 200 {
 201   int type = sock->typeinfo->type;
 202   int subtype = sock->typeinfo->subtype;
 203
 204   if (sock->default_value) {
 205     return; /* already initialized */
 206   }
 207
 208   switch (type) {
 209     case SOCK_FLOAT: {
 210       bNodeSocketValueFloat *dval = (bNodeSocketValueFloat *)MEM_callocN(
 211           sizeof(bNodeSocketValueFloat), "node socket value float");
 212       dval->subtype = subtype;
 213       dval->value = 0.0f;
 214       dval->min = -FLT_MAX;
 215       dval->max = FLT_MAX;
 216
 217       sock->default_value = dval;
 218       break;
 219     }
 220     case SOCK_INT: {
 221       bNodeSocketValueInt *dval = (bNodeSocketValueInt *)MEM_callocN(sizeof(bNodeSocketValueInt),
 222                                                                      "node socket value int");
 223       dval->subtype = subtype;
 224       dval->value = 0;
 225       dval->min = INT_MIN;
 226       dval->max = INT_MAX;
 227
 228       sock->default_value = dval;
 229       break;
 230     }
 231     case SOCK_BOOLEAN: {
 232       bNodeSocketValueBoolean *dval = (bNodeSocketValueBoolean *)MEM_callocN(
 233           sizeof(bNodeSocketValueBoolean), "node socket value bool");
 234       dval->value = false;
 235
 236       sock->default_value = dval;
 237       break;
 238     }
 239     case SOCK_VECTOR: {
 240       static float default_value[] = {0.0f, 0.0f, 0.0f};
 241       bNodeSocketValueVector *dval = (bNodeSocketValueVector *)MEM_callocN(
 242           sizeof(bNodeSocketValueVector), "node socket value vector");
 243       dval->subtype = subtype;
 244       copy_v3_v3(dval->value, default_value);
 245       dval->min = -FLT_MAX;
 246       dval->max = FLT_MAX;
 247
 248       sock->default_value = dval;
 249       break;
 250     }
 251     case SOCK_RGBA: {
 252       static float default_value[] = {0.0f, 0.0f, 0.0f, 1.0f};
 253       bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA *)MEM_callocN(
 254           sizeof(bNodeSocketValueRGBA), "node socket value color");
 255       copy_v4_v4(dval->value, default_value);
 256
 257       sock->default_value = dval;
 258       break;
 259     }
 260     case SOCK_STRING: {
 261       bNodeSocketValueString *dval = (bNodeSocketValueString *)MEM_callocN(
 262           sizeof(bNodeSocketValueString), "node socket value string");
 263       dval->subtype = subtype;
 264       dval->value[0] = '\0';
 265
 266       sock->default_value = dval;
 267       break;
 268     }
 269     case SOCK_OBJECT: {
 270       bNodeSocketValueObject *dval = (bNodeSocketValueObject *)MEM_callocN(
 271           sizeof(bNodeSocketValueObject), "node socket value object");
 272       dval->value = nullptr;
 273
 274       sock->default_value = dval;
 275       break;
 276     }
 277     case SOCK_IMAGE: {
 278       bNodeSocketValueImage *dval = (bNodeSocketValueImage *)MEM_callocN(
 279           sizeof(bNodeSocketValueImage), "node socket value image");
 280       dval->value = nullptr;
 281
 282       sock->default_value = dval;
 283       break;
 284     }
 285     case SOCK_COLLECTION: {
 286       bNodeSocketValueCollection *dval = (bNodeSocketValueCollection *)MEM_callocN(
 287           sizeof(bNodeSocketValueCollection), "node socket value object");
 288       dval->value = nullptr;
 289
 290       sock->default_value = dval;
 291       break;
 292       break;
 293     }
 294   }
 295 }
 296
 297 void node_socket_copy_default_value(bNodeSocket *to, const bNodeSocket *from)
 298 {
 299   /* sanity check */
 300   if (to->type != from->type) {
 301     return;
 302   }
 303
 304   /* make sure both exist */
 305   if (!from->default_value) {
 306     return;
 307   }
 308   node_socket_init_default_value(to);
 309
 310   /* use label instead of name if it has been set */
 311   if (from->label[0] != '\0') {
 312     BLI_strncpy(to->name, from->label, NODE_MAXSTR);
 313   }
 314
 315   switch (from->typeinfo->type) {
 316     case SOCK_FLOAT: {
 317       bNodeSocketValueFloat *toval = (bNodeSocketValueFloat *)to->default_value;
 318       bNodeSocketValueFloat *fromval = (bNodeSocketValueFloat *)from->default_value;
 319       *toval = *fromval;
 320       break;
 321     }
 322     case SOCK_INT: {
 323       bNodeSocketValueInt *toval = (bNodeSocketValueInt *)to->default_value;
 324       bNodeSocketValueInt *fromval = (bNodeSocketValueInt *)from->default_value;
 325       *toval = *fromval;
 326       break;
 327     }
 328     case SOCK_BOOLEAN: {
 329       bNodeSocketValueBoolean *toval = (bNodeSocketValueBoolean *)to->default_value;
 330       bNodeSocketValueBoolean *fromval = (bNodeSocketValueBoolean *)from->default_value;
 331       *toval = *fromval;
 332       break;
 333     }
 334     case SOCK_VECTOR: {
 335       bNodeSocketValueVector *toval = (bNodeSocketValueVector *)to->default_value;
 336       bNodeSocketValueVector *fromval = (bNodeSocketValueVector *)from->default_value;
 337       *toval = *fromval;
 338       break;
 339     }
 340     case SOCK_RGBA: {
 341       bNodeSocketValueRGBA *toval = (bNodeSocketValueRGBA *)to->default_value;
 342       bNodeSocketValueRGBA *fromval = (bNodeSocketValueRGBA *)from->default_value;
 343       *toval = *fromval;
 344       break;
 345     }
 346     case SOCK_STRING: {
 347       bNodeSocketValueString *toval = (bNodeSocketValueString *)to->default_value;
 348       bNodeSocketValueString *fromval = (bNodeSocketValueString *)from->default_value;
 349       *toval = *fromval;
 350       break;
 351     }
 352     case SOCK_OBJECT: {
 353       bNodeSocketValueObject *toval = (bNodeSocketValueObject *)to->default_value;
 354       bNodeSocketValueObject *fromval = (bNodeSocketValueObject *)from->default_value;
 355       *toval = *fromval;
 356       id_us_plus(&toval->value->id);
 357       break;
 358     }
 359     case SOCK_IMAGE: {
 360       bNodeSocketValueImage *toval = (bNodeSocketValueImage *)to->default_value;
 361       bNodeSocketValueImage *fromval = (bNodeSocketValueImage *)from->default_value;
 362       *toval = *fromval;
 363       id_us_plus(&toval->value->id);
 364       break;
 365     }
 366     case SOCK_COLLECTION: {
 367       bNodeSocketValueCollection *toval = (bNodeSocketValueCollection *)to->default_value;
 368       bNodeSocketValueCollection *fromval = (bNodeSocketValueCollection *)from->default_value;
 369       *toval = *fromval;
 370       id_us_plus(&toval->value->id);
 371       break;
 372     }
 373   }
 374
 375   to->flag |= (from->flag & SOCK_HIDE_VALUE);
 376 }
 377
 378 void node_socket_skip_reroutes(
 379     ListBase *links, bNode *node, bNodeSocket *socket, bNode **r_node, bNodeSocket **r_socket)
 380 {
 381   const int loop_limit = 100; /* Limit in case there is a connection cycle. */
 382
 383   if (socket->in_out == SOCK_IN) {
 384     bNodeLink *first_link = (bNodeLink *)links->first;
 385
 386     for (int i = 0; node->type == NODE_REROUTE && i < loop_limit; i++) {
 387       bNodeLink *link = first_link;
 388
 389       for (; link; link = link->next) {
 390         if (link->fromnode == node && link->tonode != node) {
 391           break;
 392         }
 393       }
 394
 395       if (link) {
 396         node = link->tonode;
 397         socket = link->tosock;
 398       }
 399       else {
 400         break;
 401       }
 402     }
 403   }
 404   else {
 405     for (int i = 0; node->type == NODE_REROUTE && i < loop_limit; i++) {
 406       bNodeSocket *input = (bNodeSocket *)node->inputs.first;
 407
 408       if (input && input->link) {
 409         node = input->link->fromnode;
 410         socket = input->link->fromsock;
 411       }
 412       else {
 413         break;
 414       }
 415     }
 416   }
 417
 418   if (r_node) {
 419     *r_node = node;
 420   }
 421   if (r_socket) {
 422     *r_socket = socket;
 423   }
 424 }
 425
 426 static void standard_node_socket_interface_init_socket(bNodeTree *UNUSED(ntree),
 427                                                        bNodeSocket *stemp,
 428                                                        bNode *UNUSED(node),
 429                                                        bNodeSocket *sock,
 430                                                        const char *UNUSED(data_path))
 431 {
 432   /* initialize the type value */
 433   sock->type = sock->typeinfo->type;
 434
 435   /* XXX socket interface 'type' value is not used really,
 436    * but has to match or the copy function will bail out
 437    */
 438   stemp->type = stemp->typeinfo->type;
 439   /* copy default_value settings */
 440   node_socket_copy_default_value(sock, stemp);
 441 }
 442
 443 /* copies settings that are not changed for each socket instance */
 444 static void standard_node_socket_interface_verify_socket(bNodeTree *UNUSED(ntree),
 445                                                          bNodeSocket *stemp,
 446                                                          bNode *UNUSED(node),
 447                                                          bNodeSocket *sock,
 448                                                          const char *UNUSED(data_path))
 449 {
 450   /* sanity check */
 451   if (sock->type != stemp->typeinfo->type) {
 452     return;
 453   }
 454
 455   /* make sure both exist */
 456   if (!stemp->default_value) {
 457     return;
 458   }
 459   node_socket_init_default_value(sock);
 460
 461   switch (stemp->typeinfo->type) {
 462     case SOCK_FLOAT: {
 463       bNodeSocketValueFloat *toval = (bNodeSocketValueFloat *)sock->default_value;
 464       bNodeSocketValueFloat *fromval = (bNodeSocketValueFloat *)stemp->default_value;
 465       toval->min = fromval->min;
 466       toval->max = fromval->max;
 467       break;
 468     }
 469     case SOCK_INT: {
 470       bNodeSocketValueInt *toval = (bNodeSocketValueInt *)sock->default_value;
 471       bNodeSocketValueInt *fromval = (bNodeSocketValueInt *)stemp->default_value;
 472       toval->min = fromval->min;
 473       toval->max = fromval->max;
 474       break;
 475     }
 476     case SOCK_VECTOR: {
 477       bNodeSocketValueVector *toval = (bNodeSocketValueVector *)sock->default_value;
 478       bNodeSocketValueVector *fromval = (bNodeSocketValueVector *)stemp->default_value;
 479       toval->min = fromval->min;
 480       toval->max = fromval->max;
 481       break;
 482     }
 483   }
 484 }
 485
 486 static void standard_node_socket_interface_from_socket(bNodeTree *UNUSED(ntree),
 487                                                        bNodeSocket *stemp,
 488                                                        bNode *UNUSED(node),
 489                                                        bNodeSocket *sock)
 490 {
 491   /* initialize settings */
 492   stemp->type = stemp->typeinfo->type;
 493   node_socket_copy_default_value(stemp, sock);
 494 }
 495
 496 extern "C" void ED_init_standard_node_socket_type(bNodeSocketType *);
 497
 498 static bNodeSocketType *make_standard_socket_type(int type, int subtype)
 499 {
 500   const char *socket_idname = nodeStaticSocketType(type, subtype);
 501   const char *interface_idname = nodeStaticSocketInterfaceType(type, subtype);
 502   bNodeSocketType *stype;
 503   StructRNA *srna;
 504
 505   stype = (bNodeSocketType *)MEM_callocN(sizeof(bNodeSocketType), "node socket C type");
 506   stype->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
 507   BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname));
 508
 509   /* set the RNA type
 510    * uses the exact same identifier as the socket type idname */
 511   srna = stype->ext_socket.srna = RNA_struct_find(socket_idname);
 512   BLI_assert(srna != nullptr);
 513   /* associate the RNA type with the socket type */
 514   RNA_struct_blender_type_set(srna, stype);
 515
 516   /* set the interface RNA type */
 517   srna = stype->ext_interface.srna = RNA_struct_find(interface_idname);
 518   BLI_assert(srna != nullptr);
 519   /* associate the RNA type with the socket type */
 520   RNA_struct_blender_type_set(srna, stype);
 521
 522   /* extra type info for standard socket types */
 523   stype->type = type;
 524   stype->subtype = subtype;
 525
 526   /* XXX bad-level call! needed for setting draw callbacks */
 527   ED_init_standard_node_socket_type(stype);
 528
 529   stype->interface_init_socket = standard_node_socket_interface_init_socket;
 530   stype->interface_from_socket = standard_node_socket_interface_from_socket;
 531   stype->interface_verify_socket = standard_node_socket_interface_verify_socket;
 532
 533   stype->use_link_limits_of_type = true;
 534   stype->input_link_limit = 1;
 535   stype->output_link_limit = 0xFFF;
 536
 537   return stype;
 538 }
 539
 540 extern "C" void ED_init_node_socket_type_virtual(bNodeSocketType *);
 541
 542 static bNodeSocketType *make_socket_type_virtual()
 543 {
 544   const char *socket_idname = "NodeSocketVirtual";
 545   bNodeSocketType *stype;
 546   StructRNA *srna;
 547
 548   stype = (bNodeSocketType *)MEM_callocN(sizeof(bNodeSocketType), "node socket C type");
 549   stype->free_self = (void (*)(bNodeSocketType * stype)) MEM_freeN;
 550   BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname));
 551
 552   /* set the RNA type
 553    * uses the exact same identifier as the socket type idname */
 554   srna = stype->ext_socket.srna = RNA_struct_find(socket_idname);
 555   BLI_assert(srna != nullptr);
 556   /* associate the RNA type with the socket type */
 557   RNA_struct_blender_type_set(srna, stype);
 558
 559   /* extra type info for standard socket types */
 560   stype->type = SOCK_CUSTOM;
 561
 562   ED_init_node_socket_type_virtual(stype);
 563
 564   stype->use_link_limits_of_type = true;
 565   stype->input_link_limit = 0xFFF;
 566   stype->output_link_limit = 0xFFF;
 567
 568   return stype;
 569 }
 570
 571 static bNodeSocketType *make_socket_type_bool()
 572 {
 573   bNodeSocketType *socktype = make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE);
 574   socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<bool>(); };
 575   socktype->get_cpp_value = [](const bNodeSocket &socket, void *r_value) {
 576     *(bool *)r_value = ((bNodeSocketValueBoolean *)socket.default_value)->value;
 577   };
 578   return socktype;
 579 }
 580
 581 static bNodeSocketType *make_socket_type_float(PropertySubType subtype)
 582 {
 583   bNodeSocketType *socktype = make_standard_socket_type(SOCK_FLOAT, subtype);
 584   socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<float>(); };
 585   socktype->get_cpp_value = [](const bNodeSocket &socket, void *r_value) {
 586     *(float *)r_value = ((bNodeSocketValueFloat *)socket.default_value)->value;
 587   };
 588   return socktype;
 589 }
 590
 591 static bNodeSocketType *make_socket_type_int(PropertySubType subtype)
 592 {
 593   bNodeSocketType *socktype = make_standard_socket_type(SOCK_INT, subtype);
 594   socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<int>(); };
 595   socktype->get_cpp_value = [](const bNodeSocket &socket, void *r_value) {
 596     *(int *)r_value = ((bNodeSocketValueInt *)socket.default_value)->value;
 597   };
 598   return socktype;
 599 }
 600
 601 static bNodeSocketType *make_socket_type_vector(PropertySubType subtype)
 602 {
 603   bNodeSocketType *socktype = make_standard_socket_type(SOCK_VECTOR, subtype);
 604   socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<blender::float3>(); };
 605   socktype->get_cpp_value = [](const bNodeSocket &socket, void *r_value) {
 606     *(blender::float3 *)r_value = ((bNodeSocketValueVector *)socket.default_value)->value;
 607   };
 608   return socktype;
 609 }
 610
 611 static bNodeSocketType *make_socket_type_rgba()
 612 {
 613   bNodeSocketType *socktype = make_standard_socket_type(SOCK_RGBA, PROP_NONE);
 614   socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<blender::Color4f>(); };
 615   socktype->get_cpp_value = [](const bNodeSocket &socket, void *r_value) {
 616     *(blender::Color4f *)r_value = ((bNodeSocketValueRGBA *)socket.default_value)->value;
 617   };
 618   return socktype;
 619 }
 620
 621 static bNodeSocketType *make_socket_type_string()
 622 {
 623   bNodeSocketType *socktype = make_standard_socket_type(SOCK_STRING, PROP_NONE);
 624   socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<std::string>(); };
 625   socktype->get_cpp_value = [](const bNodeSocket &socket, void *r_value) {
 626     new (r_value) std::string(((bNodeSocketValueString *)socket.default_value)->value);
 627   };
 628   return socktype;
 629 }
 630
 631 class ObjectSocketMultiFunction : public blender::fn::MultiFunction {
 632  private:
 633   Object *object_;
 634
 635  public:
 636   ObjectSocketMultiFunction(Object *object) : object_(object)
 637   {
 638     blender::fn::MFSignatureBuilder signature = this->get_builder("Object Socket");
 639     signature.depends_on_context();
 640     signature.single_output<blender::bke::PersistentObjectHandle>("Object");
 641   }
 642
 643   void call(blender::IndexMask mask,
 644             blender::fn::MFParams params,
 645             blender::fn::MFContext context) const override
 646   {
 647     blender::MutableSpan output =
 648         params.uninitialized_single_output<blender::bke::PersistentObjectHandle>(0, "Object");
 649
 650     /* Try to get a handle map, so that the object can be converted to a handle. */
 651     const blender::bke::PersistentDataHandleMap *handle_map =
 652         context.get_global_context<blender::bke::PersistentDataHandleMap>(
 653             "PersistentDataHandleMap");
 654
 655     if (handle_map == nullptr) {
 656       /* Return empty handles when there is no handle map. */
 657       output.fill_indices(mask, blender::bke::PersistentObjectHandle());
 658       return;
 659     }
 660
 661     blender::bke::PersistentObjectHandle handle = handle_map->lookup(object_);
 662     for (int64_t i : mask) {
 663       output[i] = handle;
 664     }
 665   }
 666 };
 667
 668 MAKE_CPP_TYPE(PersistentObjectHandle, blender::bke::PersistentObjectHandle);
 669 MAKE_CPP_TYPE(PersistentCollectionHandle, blender::bke::PersistentCollectionHandle);
 670
 671 static bNodeSocketType *make_socket_type_object()
 672 {
 673   bNodeSocketType *socktype = make_standard_socket_type(SOCK_OBJECT, PROP_NONE);
 674   socktype->get_cpp_type = []() {
 675     /* Objects are not passed along as raw pointers, but as handles. */
 676     return &blender::fn::CPPType::get<blender::bke::PersistentObjectHandle>();
 677   };
 678   socktype->expand_in_mf_network = [](blender::nodes::SocketMFNetworkBuilder &builder) {
 679     Object *object = builder.socket_default_value<bNodeSocketValueObject>()->value;
 680     builder.construct_generator_fn<ObjectSocketMultiFunction>(object);
 681   };
 682   return socktype;
 683 }
 684
 685 static bNodeSocketType *make_socket_type_geometry()
 686 {
 687   bNodeSocketType *socktype = make_standard_socket_type(SOCK_GEOMETRY, PROP_NONE);
 688   socktype->get_cpp_type = []() { return &blender::fn::CPPType::get<GeometrySet>(); };
 689   socktype->get_cpp_value = [](const bNodeSocket &UNUSED(socket), void *r_value) {
 690     new (r_value) GeometrySet();
 691   };
 692   return socktype;
 693 }
 694
 695 static bNodeSocketType *make_socket_type_collection()
 696 {
 697   bNodeSocketType *socktype = make_standard_socket_type(SOCK_COLLECTION, PROP_NONE);
 698   socktype->get_cpp_type = []() {
 699     /* Objects are not passed along as raw pointers, but as handles. */
 700     return &blender::fn::CPPType::get<blender::bke::PersistentCollectionHandle>();
 701   };
 702   return socktype;
 703 }
 704
 705 void register_standard_node_socket_types(void)
 706 {
 707   /* draw callbacks are set in drawnode.c to avoid bad-level calls */
 708
 709   nodeRegisterSocketType(make_socket_type_float(PROP_NONE));
 710   nodeRegisterSocketType(make_socket_type_float(PROP_UNSIGNED));
 711   nodeRegisterSocketType(make_socket_type_float(PROP_PERCENTAGE));
 712   nodeRegisterSocketType(make_socket_type_float(PROP_FACTOR));
 713   nodeRegisterSocketType(make_socket_type_float(PROP_ANGLE));
 714   nodeRegisterSocketType(make_socket_type_float(PROP_TIME));
 715
 716   nodeRegisterSocketType(make_socket_type_int(PROP_NONE));
 717   nodeRegisterSocketType(make_socket_type_int(PROP_UNSIGNED));
 718   nodeRegisterSocketType(make_socket_type_int(PROP_PERCENTAGE));
 719   nodeRegisterSocketType(make_socket_type_int(PROP_FACTOR));
 720
 721   nodeRegisterSocketType(make_socket_type_bool());
 722
 723   nodeRegisterSocketType(make_socket_type_vector(PROP_NONE));
 724   nodeRegisterSocketType(make_socket_type_vector(PROP_TRANSLATION));
 725   nodeRegisterSocketType(make_socket_type_vector(PROP_DIRECTION));
 726   nodeRegisterSocketType(make_socket_type_vector(PROP_VELOCITY));
 727   nodeRegisterSocketType(make_socket_type_vector(PROP_ACCELERATION));
 728   nodeRegisterSocketType(make_socket_type_vector(PROP_EULER));
 729   nodeRegisterSocketType(make_socket_type_vector(PROP_XYZ));
 730
 731   nodeRegisterSocketType(make_socket_type_rgba());
 732
 733   nodeRegisterSocketType(make_socket_type_string());
 734
 735   nodeRegisterSocketType(make_standard_socket_type(SOCK_SHADER, PROP_NONE));
 736
 737   nodeRegisterSocketType(make_socket_type_object());
 738
 739   nodeRegisterSocketType(make_standard_socket_type(SOCK_IMAGE, PROP_NONE));
 740
 741   nodeRegisterSocketType(make_socket_type_geometry());
 742
 743   nodeRegisterSocketType(make_socket_type_collection());
 744
 745   nodeRegisterSocketType(make_socket_type_virtual());
 746 }