Cleanup: remove superfluous `animsys_evaluate_action_ex()` call
[blender.git] / 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 }