Cleanup: reorder report argument for pointer assignment
[blender.git] / source / blender / makesrna / intern / rna_nodetree.c
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
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22 #include <string.h>
23 #include <limits.h>
24
25 #include "BLI_math.h"
26 #include "BLI_utildefines.h"
27
28 #include "BLT_translation.h"
29
30 #include "DNA_material_types.h"
31 #include "DNA_mesh_types.h"
32 #include "DNA_node_types.h"
33 #include "DNA_object_types.h"
34 #include "DNA_particle_types.h"
35 #include "DNA_text_types.h"
36 #include "DNA_texture_types.h"
37
38 #include "BKE_animsys.h"
39 #include "BKE_node.h"
40 #include "BKE_image.h"
41 #include "BKE_texture.h"
42
43 #include "RNA_access.h"
44 #include "RNA_define.h"
45 #include "RNA_enum_types.h"
46
47 #include "rna_internal.h"
48 #include "rna_internal_types.h"
49
50 #include "IMB_imbuf.h"
51 #include "IMB_imbuf_types.h"
52
53 #include "WM_types.h"
54
55 #include "MEM_guardedalloc.h"
56
57 #include "RE_render_ext.h"
58
59 #include "DEG_depsgraph.h"
60 #include "DEG_depsgraph_query.h"
61
62 const EnumPropertyItem rna_enum_node_socket_in_out_items[] = {
63     {SOCK_IN, "IN", 0, "Input", ""}, {SOCK_OUT, "OUT", 0, "Output", ""}, {0, NULL, 0, NULL, NULL}};
64
65 #ifndef RNA_RUNTIME
66 static const EnumPropertyItem rna_enum_node_socket_draw_shape_items[] = {
67     {SOCK_DRAW_SHAPE_CIRCLE, "CIRCLE", 0, "Circle", ""},
68     {SOCK_DRAW_SHAPE_SQUARE, "SQUARE", 0, "Square", ""},
69     {SOCK_DRAW_SHAPE_DIAMOND, "DIAMOND", 0, "Diamond", ""},
70     {0, NULL, 0, NULL, NULL}};
71
72 static const EnumPropertyItem node_socket_type_items[] = {
73     {SOCK_CUSTOM, "CUSTOM", 0, "Custom", ""},
74     {SOCK_FLOAT, "VALUE", 0, "Value", ""},
75     {SOCK_INT, "INT", 0, "Int", ""},
76     {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
77     {SOCK_VECTOR, "VECTOR", 0, "Vector", ""},
78     {SOCK_STRING, "STRING", 0, "String", ""},
79     {SOCK_RGBA, "RGBA", 0, "RGBA", ""},
80     {SOCK_SHADER, "SHADER", 0, "Shader", ""},
81     {0, NULL, 0, NULL, NULL},
82 };
83
84 static const EnumPropertyItem node_quality_items[] = {
85     {NTREE_QUALITY_HIGH, "HIGH", 0, "High", "High quality"},
86     {NTREE_QUALITY_MEDIUM, "MEDIUM", 0, "Medium", "Medium quality"},
87     {NTREE_QUALITY_LOW, "LOW", 0, "Low", "Low quality"},
88     {0, NULL, 0, NULL, NULL},
89 };
90
91 static const EnumPropertyItem node_chunksize_items[] = {
92     {NTREE_CHUNCKSIZE_32, "32", 0, "32x32", "Chunksize of 32x32"},
93     {NTREE_CHUNCKSIZE_64, "64", 0, "64x64", "Chunksize of 64x64"},
94     {NTREE_CHUNCKSIZE_128, "128", 0, "128x128", "Chunksize of 128x128"},
95     {NTREE_CHUNCKSIZE_256, "256", 0, "256x256", "Chunksize of 256x256"},
96     {NTREE_CHUNCKSIZE_512, "512", 0, "512x512", "Chunksize of 512x512"},
97     {NTREE_CHUNCKSIZE_1024, "1024", 0, "1024x1024", "Chunksize of 1024x1024"},
98     {0, NULL, 0, NULL, NULL},
99 };
100 #endif
101
102 const EnumPropertyItem rna_enum_node_math_items[] = {
103     {NODE_MATH_ADD, "ADD", 0, "Add", ""},
104     {NODE_MATH_SUB, "SUBTRACT", 0, "Subtract", ""},
105     {NODE_MATH_MUL, "MULTIPLY", 0, "Multiply", ""},
106     {NODE_MATH_DIVIDE, "DIVIDE", 0, "Divide", ""},
107     {0, "", ICON_NONE, NULL, NULL},
108     {NODE_MATH_POW, "POWER", 0, "Power", ""},
109     {NODE_MATH_LOG, "LOGARITHM", 0, "Logarithm", ""},
110     {NODE_MATH_SQRT, "SQRT", 0, "Square Root", ""},
111     {NODE_MATH_ABS, "ABSOLUTE", 0, "Absolute", ""},
112     {0, "", ICON_NONE, NULL, NULL},
113     {NODE_MATH_MIN, "MINIMUM", 0, "Minimum", ""},
114     {NODE_MATH_MAX, "MAXIMUM", 0, "Maximum", ""},
115     {NODE_MATH_LESS, "LESS_THAN", 0, "Less Than", ""},
116     {NODE_MATH_GREATER, "GREATER_THAN", 0, "Greater Than", ""},
117     {0, "", ICON_NONE, NULL, NULL},
118     {NODE_MATH_ROUND, "ROUND", 0, "Round", ""},
119     {NODE_MATH_FLOOR, "FLOOR", 0, "Floor", ""},
120     {NODE_MATH_CEIL, "CEIL", 0, "Ceil", ""},
121     {NODE_MATH_FRACT, "FRACT", 0, "Fract", ""},
122     {NODE_MATH_MOD, "MODULO", 0, "Modulo", ""},
123     {0, "", ICON_NONE, NULL, NULL},
124     {NODE_MATH_SIN, "SINE", 0, "Sine", ""},
125     {NODE_MATH_COS, "COSINE", 0, "Cosine", ""},
126     {NODE_MATH_TAN, "TANGENT", 0, "Tangent", ""},
127     {NODE_MATH_ASIN, "ARCSINE", 0, "Arcsine", ""},
128     {NODE_MATH_ACOS, "ARCCOSINE", 0, "Arccosine", ""},
129     {NODE_MATH_ATAN, "ARCTANGENT", 0, "Arctangent", ""},
130     {NODE_MATH_ATAN2, "ARCTAN2", 0, "Arctan2", ""},
131     {0, NULL, 0, NULL, NULL},
132 };
133
134 const EnumPropertyItem rna_enum_node_vec_math_items[] = {
135     {0, "ADD", 0, "Add", ""},
136     {1, "SUBTRACT", 0, "Subtract", ""},
137     {2, "AVERAGE", 0, "Average", ""},
138     {3, "DOT_PRODUCT", 0, "Dot Product", ""},
139     {4, "CROSS_PRODUCT", 0, "Cross Product", ""},
140     {5, "NORMALIZE", 0, "Normalize", ""},
141     {0, NULL, 0, NULL, NULL},
142 };
143
144 const EnumPropertyItem rna_enum_node_filter_items[] = {
145     {0, "SOFTEN", 0, "Soften", ""},
146     {1, "SHARPEN", 0, "Sharpen", ""},
147     {2, "LAPLACE", 0, "Laplace", ""},
148     {3, "SOBEL", 0, "Sobel", ""},
149     {4, "PREWITT", 0, "Prewitt", ""},
150     {5, "KIRSCH", 0, "Kirsch", ""},
151     {6, "SHADOW", 0, "Shadow", ""},
152     {0, NULL, 0, NULL, NULL},
153 };
154
155 #ifndef RNA_RUNTIME
156 static const EnumPropertyItem node_sampler_type_items[] = {
157     {0, "NEAREST", 0, "Nearest", ""},
158     {1, "BILINEAR", 0, "Bilinear", ""},
159     {2, "BICUBIC", 0, "Bicubic", ""},
160     {0, NULL, 0, NULL, NULL},
161 };
162
163 static const EnumPropertyItem prop_shader_output_target_items[] = {
164     {SHD_OUTPUT_ALL,
165      "ALL",
166      0,
167      "All",
168      "Use shaders for all renderers and viewports, unless there exists a more specific output"},
169     {SHD_OUTPUT_EEVEE, "EEVEE", 0, "Eevee", "Use shaders for Eevee renderer"},
170     {SHD_OUTPUT_CYCLES, "CYCLES", 0, "Cycles", "Use shaders for Cycles renderer"},
171     {0, NULL, 0, NULL, NULL},
172 };
173 #endif
174
175 #ifdef RNA_RUNTIME
176
177 #  include "BLI_linklist.h"
178 #  include "BLI_string.h"
179
180 #  include "BKE_context.h"
181 #  include "BKE_idprop.h"
182
183 #  include "BKE_global.h"
184
185 #  include "ED_node.h"
186 #  include "ED_render.h"
187
188 #  include "GPU_material.h"
189
190 #  include "NOD_common.h"
191 #  include "NOD_socket.h"
192 #  include "NOD_shader.h"
193 #  include "NOD_composite.h"
194
195 #  include "RE_engine.h"
196 #  include "RE_pipeline.h"
197
198 #  include "DNA_scene_types.h"
199 #  include "WM_api.h"
200
201 int rna_node_tree_type_to_enum(bNodeTreeType *typeinfo)
202 {
203   int i = 0, result = -1;
204   NODE_TREE_TYPES_BEGIN (nt) {
205     if (nt == typeinfo) {
206       result = i;
207       break;
208     }
209     ++i;
210   }
211   NODE_TREE_TYPES_END;
212   return result;
213 }
214
215 int rna_node_tree_idname_to_enum(const char *idname)
216 {
217   int i = 0, result = -1;
218   NODE_TREE_TYPES_BEGIN (nt) {
219     if (STREQ(nt->idname, idname)) {
220       result = i;
221       break;
222     }
223     ++i;
224   }
225   NODE_TREE_TYPES_END;
226   return result;
227 }
228
229 bNodeTreeType *rna_node_tree_type_from_enum(int value)
230 {
231   int i = 0;
232   bNodeTreeType *result = NULL;
233   NODE_TREE_TYPES_BEGIN (nt) {
234     if (i == value) {
235       result = nt;
236       break;
237     }
238     ++i;
239   }
240   NODE_TREE_TYPES_END;
241   return result;
242 }
243
244 const EnumPropertyItem *rna_node_tree_type_itemf(void *data,
245                                                  bool (*poll)(void *data, bNodeTreeType *),
246                                                  bool *r_free)
247 {
248   EnumPropertyItem tmp = {0};
249   EnumPropertyItem *item = NULL;
250   int totitem = 0, i = 0;
251
252   NODE_TREE_TYPES_BEGIN (nt) {
253     if (poll && !poll(data, nt)) {
254       ++i;
255       continue;
256     }
257
258     tmp.value = i;
259     tmp.identifier = nt->idname;
260     tmp.icon = nt->ui_icon;
261     tmp.name = nt->ui_name;
262     tmp.description = nt->ui_description;
263
264     RNA_enum_item_add(&item, &totitem, &tmp);
265
266     ++i;
267   }
268   NODE_TREE_TYPES_END;
269
270   if (totitem == 0) {
271     *r_free = false;
272     return DummyRNA_NULL_items;
273   }
274
275   RNA_enum_item_end(&item, &totitem);
276   *r_free = true;
277
278   return item;
279 }
280
281 int rna_node_type_to_enum(bNodeType *typeinfo)
282 {
283   int i = 0, result = -1;
284   NODE_TYPES_BEGIN (ntype) {
285     if (ntype == typeinfo) {
286       result = i;
287       break;
288     }
289     ++i;
290   }
291   NODE_TYPES_END;
292   return result;
293 }
294
295 int rna_node_idname_to_enum(const char *idname)
296 {
297   int i = 0, result = -1;
298   NODE_TYPES_BEGIN (ntype) {
299     if (STREQ(ntype->idname, idname)) {
300       result = i;
301       break;
302     }
303     ++i;
304   }
305   NODE_TYPES_END;
306   return result;
307 }
308
309 bNodeType *rna_node_type_from_enum(int value)
310 {
311   int i = 0;
312   bNodeType *result = NULL;
313   NODE_TYPES_BEGIN (ntype) {
314     if (i == value) {
315       result = ntype;
316       break;
317     }
318     ++i;
319   }
320   NODE_TYPES_END;
321   return result;
322 }
323
324 const EnumPropertyItem *rna_node_type_itemf(void *data,
325                                             bool (*poll)(void *data, bNodeType *),
326                                             bool *r_free)
327 {
328   EnumPropertyItem *item = NULL;
329   EnumPropertyItem tmp = {0};
330   int totitem = 0, i = 0;
331
332   NODE_TYPES_BEGIN (ntype) {
333     if (poll && !poll(data, ntype)) {
334       ++i;
335       continue;
336     }
337
338     tmp.value = i;
339     tmp.identifier = ntype->idname;
340     tmp.icon = ntype->ui_icon;
341     tmp.name = ntype->ui_name;
342     tmp.description = ntype->ui_description;
343
344     RNA_enum_item_add(&item, &totitem, &tmp);
345
346     ++i;
347   }
348   NODE_TYPES_END;
349
350   if (totitem == 0) {
351     *r_free = false;
352     return DummyRNA_NULL_items;
353   }
354
355   RNA_enum_item_end(&item, &totitem);
356   *r_free = true;
357
358   return item;
359 }
360
361 int rna_node_socket_type_to_enum(bNodeSocketType *typeinfo)
362 {
363   int i = 0, result = -1;
364   NODE_SOCKET_TYPES_BEGIN (stype) {
365     if (stype == typeinfo) {
366       result = i;
367       break;
368     }
369     ++i;
370   }
371   NODE_SOCKET_TYPES_END;
372   return result;
373 }
374
375 int rna_node_socket_idname_to_enum(const char *idname)
376 {
377   int i = 0, result = -1;
378   NODE_SOCKET_TYPES_BEGIN (stype) {
379     if (STREQ(stype->idname, idname)) {
380       result = i;
381       break;
382     }
383     ++i;
384   }
385   NODE_SOCKET_TYPES_END;
386   return result;
387 }
388
389 bNodeSocketType *rna_node_socket_type_from_enum(int value)
390 {
391   int i = 0;
392   bNodeSocketType *result = NULL;
393   NODE_SOCKET_TYPES_BEGIN (stype) {
394     if (i == value) {
395       result = stype;
396       break;
397     }
398     ++i;
399   }
400   NODE_SOCKET_TYPES_END;
401   return result;
402 }
403
404 const EnumPropertyItem *rna_node_socket_type_itemf(void *data,
405                                                    bool (*poll)(void *data, bNodeSocketType *),
406                                                    bool *r_free)
407 {
408   EnumPropertyItem *item = NULL;
409   EnumPropertyItem tmp = {0};
410   int totitem = 0, i = 0;
411   StructRNA *srna;
412
413   NODE_SOCKET_TYPES_BEGIN (stype) {
414     if (poll && !poll(data, stype)) {
415       ++i;
416       continue;
417     }
418
419     srna = stype->ext_socket.srna;
420     tmp.value = i;
421     tmp.identifier = stype->idname;
422     tmp.icon = RNA_struct_ui_icon(srna);
423     tmp.name = RNA_struct_ui_name(srna);
424     tmp.description = RNA_struct_ui_description(srna);
425
426     RNA_enum_item_add(&item, &totitem, &tmp);
427
428     ++i;
429   }
430   NODE_SOCKET_TYPES_END;
431
432   if (totitem == 0) {
433     *r_free = false;
434     return DummyRNA_NULL_items;
435   }
436
437   RNA_enum_item_end(&item, &totitem);
438   *r_free = true;
439
440   return item;
441 }
442
443 static const EnumPropertyItem *rna_node_static_type_itemf(bContext *UNUSED(C),
444                                                           PointerRNA *ptr,
445                                                           PropertyRNA *UNUSED(prop),
446                                                           bool *r_free)
447 {
448   EnumPropertyItem *item = NULL;
449   EnumPropertyItem tmp;
450   int totitem = 0;
451
452   /* hack, don't want to add include path to RNA just for this, since in the future RNA types
453    * for nodes should be defined locally at runtime anyway ...
454    */
455
456   tmp.value = NODE_CUSTOM;
457   tmp.identifier = "CUSTOM";
458   tmp.name = "Custom";
459   tmp.description = "Custom Node";
460   tmp.icon = ICON_NONE;
461   RNA_enum_item_add(&item, &totitem, &tmp);
462
463   tmp.value = NODE_CUSTOM_GROUP;
464   tmp.identifier = "CUSTOM GROUP";
465   tmp.name = "CustomGroup";
466   tmp.description = "Custom Group Node";
467   tmp.icon = ICON_NONE;
468   RNA_enum_item_add(&item, &totitem, &tmp);
469
470   tmp.value = NODE_UNDEFINED;
471   tmp.identifier = "UNDEFINED";
472   tmp.name = "UNDEFINED";
473   tmp.description = "";
474   tmp.icon = ICON_NONE;
475   RNA_enum_item_add(&item, &totitem, &tmp);
476
477 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
478     if (STREQ(#Category, "Node")) { \
479       tmp.value = ID; \
480       tmp.identifier = EnumName; \
481       tmp.name = UIName; \
482       tmp.description = UIDesc; \
483       tmp.icon = ICON_NONE; \
484       RNA_enum_item_add(&item, &totitem, &tmp); \
485     }
486 #  include "../../nodes/NOD_static_types.h"
487 #  undef DefNode
488
489   if (RNA_struct_is_a(ptr->type, &RNA_ShaderNode)) {
490 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
491     if (STREQ(#Category, "ShaderNode")) { \
492       tmp.value = ID; \
493       tmp.identifier = EnumName; \
494       tmp.name = UIName; \
495       tmp.description = UIDesc; \
496       tmp.icon = ICON_NONE; \
497       RNA_enum_item_add(&item, &totitem, &tmp); \
498     }
499 #  include "../../nodes/NOD_static_types.h"
500 #  undef DefNode
501   }
502
503   if (RNA_struct_is_a(ptr->type, &RNA_CompositorNode)) {
504 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
505     if (STREQ(#Category, "CompositorNode")) { \
506       tmp.value = ID; \
507       tmp.identifier = EnumName; \
508       tmp.name = UIName; \
509       tmp.description = UIDesc; \
510       tmp.icon = ICON_NONE; \
511       RNA_enum_item_add(&item, &totitem, &tmp); \
512     }
513 #  include "../../nodes/NOD_static_types.h"
514 #  undef DefNode
515   }
516
517   if (RNA_struct_is_a(ptr->type, &RNA_TextureNode)) {
518 #  define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
519     if (STREQ(#Category, "TextureNode")) { \
520       tmp.value = ID; \
521       tmp.identifier = EnumName; \
522       tmp.name = UIName; \
523       tmp.description = UIDesc; \
524       tmp.icon = ICON_NONE; \
525       RNA_enum_item_add(&item, &totitem, &tmp); \
526     }
527 #  include "../../nodes/NOD_static_types.h"
528 #  undef DefNode
529   }
530
531   RNA_enum_item_end(&item, &totitem);
532   *r_free = true;
533
534   return item;
535 }
536
537 /* ******** Node Tree ******** */
538
539 static StructRNA *rna_NodeTree_refine(struct PointerRNA *ptr)
540 {
541   bNodeTree *ntree = (bNodeTree *)ptr->data;
542
543   if (ntree->typeinfo->ext.srna)
544     return ntree->typeinfo->ext.srna;
545   else
546     return &RNA_NodeTree;
547 }
548
549 static bool rna_NodeTree_poll(const bContext *C, bNodeTreeType *ntreetype)
550 {
551   extern FunctionRNA rna_NodeTree_poll_func;
552
553   PointerRNA ptr;
554   ParameterList list;
555   FunctionRNA *func;
556   void *ret;
557   bool visible;
558
559   RNA_pointer_create(NULL, ntreetype->ext.srna, NULL, &ptr); /* dummy */
560   func = &rna_NodeTree_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
561
562   RNA_parameter_list_create(&list, &ptr, func);
563   RNA_parameter_set_lookup(&list, "context", &C);
564   ntreetype->ext.call((bContext *)C, &ptr, func, &list);
565
566   RNA_parameter_get_lookup(&list, "visible", &ret);
567   visible = *(bool *)ret;
568
569   RNA_parameter_list_free(&list);
570
571   return visible;
572 }
573
574 static void rna_NodeTree_update_reg(bNodeTree *ntree)
575 {
576   extern FunctionRNA rna_NodeTree_update_func;
577
578   PointerRNA ptr;
579   ParameterList list;
580   FunctionRNA *func;
581
582   RNA_id_pointer_create(&ntree->id, &ptr);
583   func = &rna_NodeTree_update_func; /* RNA_struct_find_function(&ptr, "update"); */
584
585   RNA_parameter_list_create(&list, &ptr, func);
586   ntree->typeinfo->ext.call(NULL, &ptr, func, &list);
587
588   RNA_parameter_list_free(&list);
589 }
590
591 static void rna_NodeTree_get_from_context(
592     const bContext *C, bNodeTreeType *ntreetype, bNodeTree **r_ntree, ID **r_id, ID **r_from)
593 {
594   extern FunctionRNA rna_NodeTree_get_from_context_func;
595
596   PointerRNA ptr;
597   ParameterList list;
598   FunctionRNA *func;
599   void *ret1, *ret2, *ret3;
600
601   RNA_pointer_create(NULL, ntreetype->ext.srna, NULL, &ptr); /* dummy */
602   /* RNA_struct_find_function(&ptr, "get_from_context"); */
603   func = &rna_NodeTree_get_from_context_func;
604
605   RNA_parameter_list_create(&list, &ptr, func);
606   RNA_parameter_set_lookup(&list, "context", &C);
607   ntreetype->ext.call((bContext *)C, &ptr, func, &list);
608
609   RNA_parameter_get_lookup(&list, "result_1", &ret1);
610   RNA_parameter_get_lookup(&list, "result_2", &ret2);
611   RNA_parameter_get_lookup(&list, "result_3", &ret3);
612   *r_ntree = *(bNodeTree **)ret1;
613   *r_id = *(ID **)ret2;
614   *r_from = *(ID **)ret3;
615
616   RNA_parameter_list_free(&list);
617 }
618
619 static void rna_NodeTree_unregister(Main *UNUSED(bmain), StructRNA *type)
620 {
621   bNodeTreeType *nt = RNA_struct_blender_type_get(type);
622
623   if (!nt)
624     return;
625
626   RNA_struct_free_extension(type, &nt->ext);
627   RNA_struct_free(&BLENDER_RNA, type);
628
629   ntreeTypeFreeLink(nt);
630
631   /* update while blender is running */
632   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
633 }
634
635 static StructRNA *rna_NodeTree_register(Main *bmain,
636                                         ReportList *reports,
637                                         void *data,
638                                         const char *identifier,
639                                         StructValidateFunc validate,
640                                         StructCallbackFunc call,
641                                         StructFreeFunc free)
642 {
643   bNodeTreeType *nt, dummynt;
644   bNodeTree dummyntree;
645   PointerRNA dummyptr;
646   int have_function[3];
647
648   /* setup dummy tree & tree type to store static properties in */
649   memset(&dummynt, 0, sizeof(bNodeTreeType));
650   memset(&dummyntree, 0, sizeof(bNodeTree));
651   dummyntree.typeinfo = &dummynt;
652   RNA_pointer_create(NULL, &RNA_NodeTree, &dummyntree, &dummyptr);
653
654   /* validate the python class */
655   if (validate(&dummyptr, data, have_function) != 0)
656     return NULL;
657
658   if (strlen(identifier) >= sizeof(dummynt.idname)) {
659     BKE_reportf(reports,
660                 RPT_ERROR,
661                 "Registering node tree class: '%s' is too long, maximum length is %d",
662                 identifier,
663                 (int)sizeof(dummynt.idname));
664     return NULL;
665   }
666
667   /* check if we have registered this tree type before, and remove it */
668   nt = ntreeTypeFind(dummynt.idname);
669   if (nt) {
670     rna_NodeTree_unregister(bmain, nt->ext.srna);
671   }
672
673   /* create a new node tree type */
674   nt = MEM_callocN(sizeof(bNodeTreeType), "node tree type");
675   memcpy(nt, &dummynt, sizeof(dummynt));
676
677   nt->type = NTREE_CUSTOM;
678
679   nt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, &RNA_NodeTree);
680   nt->ext.data = data;
681   nt->ext.call = call;
682   nt->ext.free = free;
683   RNA_struct_blender_type_set(nt->ext.srna, nt);
684
685   RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description);
686   RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon);
687
688   nt->poll = (have_function[0]) ? rna_NodeTree_poll : NULL;
689   nt->update = (have_function[1]) ? rna_NodeTree_update_reg : NULL;
690   nt->get_from_context = (have_function[2]) ? rna_NodeTree_get_from_context : NULL;
691
692   ntreeTypeAdd(nt);
693
694   /* update while blender is running */
695   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
696
697   return nt->ext.srna;
698 }
699
700 static bool rna_NodeTree_check(bNodeTree *ntree, ReportList *reports)
701 {
702   if (!ntreeIsRegistered(ntree)) {
703     if (reports)
704       BKE_reportf(reports,
705                   RPT_ERROR,
706                   "Node tree '%s' has undefined type %s",
707                   ntree->id.name + 2,
708                   ntree->idname);
709
710     return false;
711   }
712   else
713     return true;
714 }
715
716 static void rna_NodeTree_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
717 {
718   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
719   bNode *node = (bNode *)ptr->data;
720
721   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
722   WM_main_add_notifier(NC_SCENE | ND_NODES, &ntree->id);
723
724   ED_node_tag_update_nodetree(bmain, ntree, node);
725 }
726
727 static bNode *rna_NodeTree_node_new(bNodeTree *ntree,
728                                     bContext *C,
729                                     ReportList *reports,
730                                     const char *type)
731 {
732   bNodeType *ntype;
733   bNode *node;
734
735   if (!rna_NodeTree_check(ntree, reports))
736     return NULL;
737
738   ntype = nodeTypeFind(type);
739   if (!ntype) {
740     BKE_reportf(reports, RPT_ERROR, "Node type %s undefined", type);
741     return NULL;
742   }
743
744   if (ntype->poll && !ntype->poll(ntype, ntree)) {
745     BKE_reportf(reports,
746                 RPT_ERROR,
747                 "Cannot add node of type %s to node tree '%s'",
748                 type,
749                 ntree->id.name + 2);
750     return NULL;
751   }
752
753   node = nodeAddNode(C, ntree, type);
754   BLI_assert(node && node->typeinfo);
755
756   if (ntree->type == NTREE_TEXTURE) {
757     ntreeTexCheckCyclics(ntree);
758   }
759
760   ntreeUpdateTree(CTX_data_main(C), ntree);
761   nodeUpdate(ntree, node);
762   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
763
764   return node;
765 }
766
767 static void rna_NodeTree_node_remove(bNodeTree *ntree,
768                                      Main *bmain,
769                                      ReportList *reports,
770                                      PointerRNA *node_ptr)
771 {
772   bNode *node = node_ptr->data;
773
774   if (!rna_NodeTree_check(ntree, reports))
775     return;
776
777   if (BLI_findindex(&ntree->nodes, node) == -1) {
778     BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name);
779     return;
780   }
781
782   nodeRemoveNode(bmain, ntree, node, true);
783
784   RNA_POINTER_INVALIDATE(node_ptr);
785
786   ntreeUpdateTree(bmain, ntree); /* update group node socket links */
787   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
788 }
789
790 static void rna_NodeTree_node_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
791 {
792   bNode *node = ntree->nodes.first;
793
794   if (!rna_NodeTree_check(ntree, reports))
795     return;
796
797   while (node) {
798     bNode *next_node = node->next;
799
800     nodeRemoveNode(bmain, ntree, node, true);
801
802     node = next_node;
803   }
804
805   ntreeUpdateTree(bmain, ntree);
806
807   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
808 }
809
810 static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr)
811 {
812   bNodeTree *ntree = (bNodeTree *)ptr->data;
813   bNode *node = nodeGetActive(ntree);
814   return rna_pointer_inherit_refine(ptr, &RNA_Node, node);
815 }
816
817 static void rna_NodeTree_active_node_set(PointerRNA *ptr,
818                                          const PointerRNA value,
819                                          struct ReportList *UNUSED(reports))
820 {
821   bNodeTree *ntree = (bNodeTree *)ptr->data;
822   bNode *node = (bNode *)value.data;
823
824   if (node && BLI_findindex(&ntree->nodes, node) != -1)
825     nodeSetActive(ntree, node);
826   else
827     nodeClearActive(ntree);
828 }
829
830 static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree,
831                                         Main *bmain,
832                                         ReportList *reports,
833                                         bNodeSocket *fromsock,
834                                         bNodeSocket *tosock,
835                                         bool verify_limits)
836 {
837   bNodeLink *ret;
838   bNode *fromnode = NULL, *tonode = NULL;
839
840   if (!rna_NodeTree_check(ntree, reports))
841     return NULL;
842
843   nodeFindNode(ntree, fromsock, &fromnode, NULL);
844   nodeFindNode(ntree, tosock, &tonode, NULL);
845   /* check validity of the sockets:
846    * if sockets from different trees are passed in this will fail!
847    */
848   if (!fromnode || !tonode)
849     return NULL;
850
851   if (&fromsock->in_out == &tosock->in_out) {
852     BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets");
853     return NULL;
854   }
855
856   if (verify_limits) {
857     /* remove other socket links if limit is exceeded */
858     if (nodeCountSocketLinks(ntree, fromsock) + 1 > fromsock->limit)
859       nodeRemSocketLinks(ntree, fromsock);
860     if (nodeCountSocketLinks(ntree, tosock) + 1 > tosock->limit)
861       nodeRemSocketLinks(ntree, tosock);
862   }
863
864   ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock);
865
866   if (ret) {
867
868     /* not an issue from the UI, clear hidden from API to keep valid state. */
869     fromsock->flag &= ~SOCK_HIDDEN;
870     tosock->flag &= ~SOCK_HIDDEN;
871
872     if (tonode)
873       nodeUpdate(ntree, tonode);
874
875     ntreeUpdateTree(bmain, ntree);
876
877     ED_node_tag_update_nodetree(bmain, ntree, ret->tonode);
878     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
879   }
880   return ret;
881 }
882
883 static void rna_NodeTree_link_remove(bNodeTree *ntree,
884                                      Main *bmain,
885                                      ReportList *reports,
886                                      PointerRNA *link_ptr)
887 {
888   bNodeLink *link = link_ptr->data;
889
890   if (!rna_NodeTree_check(ntree, reports))
891     return;
892
893   if (BLI_findindex(&ntree->links, link) == -1) {
894     BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree");
895     return;
896   }
897
898   nodeRemLink(ntree, link);
899   RNA_POINTER_INVALIDATE(link_ptr);
900
901   ntreeUpdateTree(bmain, ntree);
902   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
903 }
904
905 static void rna_NodeTree_link_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
906 {
907   bNodeLink *link = ntree->links.first;
908
909   if (!rna_NodeTree_check(ntree, reports))
910     return;
911
912   while (link) {
913     bNodeLink *next_link = link->next;
914
915     nodeRemLink(ntree, link);
916
917     link = next_link;
918   }
919   ntreeUpdateTree(bmain, ntree);
920
921   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
922 }
923
924 static int rna_NodeTree_active_input_get(PointerRNA *ptr)
925 {
926   bNodeTree *ntree = (bNodeTree *)ptr->data;
927   bNodeSocket *gsock;
928   int index;
929
930   for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index)
931     if (gsock->flag & SELECT)
932       return index;
933   return -1;
934 }
935
936 static void rna_NodeTree_active_input_set(PointerRNA *ptr, int value)
937 {
938   bNodeTree *ntree = (bNodeTree *)ptr->data;
939   bNodeSocket *gsock;
940   int index;
941
942   for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
943     if (index == value)
944       gsock->flag |= SELECT;
945     else
946       gsock->flag &= ~SELECT;
947   }
948   for (gsock = ntree->outputs.first; gsock; gsock = gsock->next) {
949     gsock->flag &= ~SELECT;
950   }
951 }
952
953 static int rna_NodeTree_active_output_get(PointerRNA *ptr)
954 {
955   bNodeTree *ntree = (bNodeTree *)ptr->data;
956   bNodeSocket *gsock;
957   int index;
958
959   for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index)
960     if (gsock->flag & SELECT)
961       return index;
962   return -1;
963 }
964
965 static void rna_NodeTree_active_output_set(PointerRNA *ptr, int value)
966 {
967   bNodeTree *ntree = (bNodeTree *)ptr->data;
968   bNodeSocket *gsock;
969   int index;
970
971   for (gsock = ntree->inputs.first; gsock; gsock = gsock->next) {
972     gsock->flag &= ~SELECT;
973   }
974   for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
975     if (index == value)
976       gsock->flag |= SELECT;
977     else
978       gsock->flag &= ~SELECT;
979   }
980 }
981
982 static bNodeSocket *rna_NodeTree_inputs_new(
983     bNodeTree *ntree, Main *bmain, ReportList *reports, const char *type, const char *name)
984 {
985   bNodeSocket *sock;
986
987   if (!rna_NodeTree_check(ntree, reports))
988     return NULL;
989
990   sock = ntreeAddSocketInterface(ntree, SOCK_IN, type, name);
991
992   ntreeUpdateTree(bmain, ntree);
993   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
994
995   return sock;
996 }
997
998 static bNodeSocket *rna_NodeTree_outputs_new(
999     bNodeTree *ntree, Main *bmain, ReportList *reports, const char *type, const char *name)
1000 {
1001   bNodeSocket *sock;
1002
1003   if (!rna_NodeTree_check(ntree, reports))
1004     return NULL;
1005
1006   sock = ntreeAddSocketInterface(ntree, SOCK_OUT, type, name);
1007
1008   ntreeUpdateTree(bmain, ntree);
1009   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1010
1011   return sock;
1012 }
1013
1014 static void rna_NodeTree_socket_remove(bNodeTree *ntree,
1015                                        Main *bmain,
1016                                        ReportList *reports,
1017                                        bNodeSocket *sock)
1018 {
1019   if (!rna_NodeTree_check(ntree, reports))
1020     return;
1021
1022   if (BLI_findindex(&ntree->inputs, sock) == -1 && BLI_findindex(&ntree->outputs, sock) == -1) {
1023     BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1024   }
1025   else {
1026     ntreeRemoveSocketInterface(ntree, sock);
1027
1028     ntreeUpdateTree(bmain, ntree);
1029     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1030   }
1031 }
1032
1033 static void rna_NodeTree_inputs_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1034 {
1035   bNodeSocket *sock, *nextsock;
1036
1037   if (!rna_NodeTree_check(ntree, reports))
1038     return;
1039
1040   for (sock = ntree->inputs.first; sock; sock = nextsock) {
1041     nextsock = sock->next;
1042     ntreeRemoveSocketInterface(ntree, sock);
1043   }
1044
1045   ntreeUpdateTree(bmain, ntree);
1046   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1047 }
1048
1049 static void rna_NodeTree_outputs_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1050 {
1051   bNodeSocket *sock, *nextsock;
1052
1053   if (!rna_NodeTree_check(ntree, reports))
1054     return;
1055
1056   for (sock = ntree->outputs.first; sock; sock = nextsock) {
1057     nextsock = sock->next;
1058     ntreeRemoveSocketInterface(ntree, sock);
1059   }
1060
1061   ntreeUpdateTree(bmain, ntree);
1062   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1063 }
1064
1065 static void rna_NodeTree_inputs_move(bNodeTree *ntree, Main *bmain, int from_index, int to_index)
1066 {
1067   bNodeSocket *sock;
1068
1069   if (from_index == to_index)
1070     return;
1071   if (from_index < 0 || to_index < 0)
1072     return;
1073
1074   sock = BLI_findlink(&ntree->inputs, from_index);
1075   if (to_index < from_index) {
1076     bNodeSocket *nextsock = BLI_findlink(&ntree->inputs, to_index);
1077     if (nextsock) {
1078       BLI_remlink(&ntree->inputs, sock);
1079       BLI_insertlinkbefore(&ntree->inputs, nextsock, sock);
1080     }
1081   }
1082   else {
1083     bNodeSocket *prevsock = BLI_findlink(&ntree->inputs, to_index);
1084     if (prevsock) {
1085       BLI_remlink(&ntree->inputs, sock);
1086       BLI_insertlinkafter(&ntree->inputs, prevsock, sock);
1087     }
1088   }
1089
1090   ntree->update |= NTREE_UPDATE_GROUP_IN;
1091
1092   ntreeUpdateTree(bmain, ntree);
1093   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1094 }
1095
1096 static void rna_NodeTree_outputs_move(bNodeTree *ntree, Main *bmain, int from_index, int to_index)
1097 {
1098   bNodeSocket *sock;
1099
1100   if (from_index == to_index)
1101     return;
1102   if (from_index < 0 || to_index < 0)
1103     return;
1104
1105   sock = BLI_findlink(&ntree->outputs, from_index);
1106   if (to_index < from_index) {
1107     bNodeSocket *nextsock = BLI_findlink(&ntree->outputs, to_index);
1108     if (nextsock) {
1109       BLI_remlink(&ntree->outputs, sock);
1110       BLI_insertlinkbefore(&ntree->outputs, nextsock, sock);
1111     }
1112   }
1113   else {
1114     bNodeSocket *prevsock = BLI_findlink(&ntree->outputs, to_index);
1115     if (prevsock) {
1116       BLI_remlink(&ntree->outputs, sock);
1117       BLI_insertlinkafter(&ntree->outputs, prevsock, sock);
1118     }
1119   }
1120
1121   ntree->update |= NTREE_UPDATE_GROUP_OUT;
1122
1123   ntreeUpdateTree(bmain, ntree);
1124   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1125 }
1126
1127 static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C)
1128 {
1129   Main *bmain = CTX_data_main(C);
1130
1131   ntree->update |= NTREE_UPDATE_GROUP;
1132   ntreeUpdateTree(bmain, ntree);
1133
1134   ED_node_tag_update_nodetree(bmain, ntree, NULL);
1135 }
1136
1137 /* ******** NodeLink ******** */
1138
1139 static bool rna_NodeLink_is_hidden_get(PointerRNA *ptr)
1140 {
1141   bNodeLink *link = ptr->data;
1142   return nodeLinkIsHidden(link);
1143 }
1144
1145 /* ******** Node ******** */
1146
1147 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
1148 {
1149   bNode *node = (bNode *)ptr->data;
1150
1151   if (node->typeinfo->ext.srna)
1152     return node->typeinfo->ext.srna;
1153   else
1154     return ptr->type;
1155 }
1156
1157 static char *rna_Node_path(PointerRNA *ptr)
1158 {
1159   bNode *node = (bNode *)ptr->data;
1160   char name_esc[sizeof(node->name) * 2];
1161
1162   BLI_strescape(name_esc, node->name, sizeof(name_esc));
1163   return BLI_sprintfN("nodes[\"%s\"]", name_esc);
1164 }
1165
1166 char *rna_Node_ImageUser_path(PointerRNA *ptr)
1167 {
1168   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1169   bNode *node;
1170   char name_esc[sizeof(node->name) * 2];
1171
1172   for (node = ntree->nodes.first; node; node = node->next) {
1173     if (node->type == SH_NODE_TEX_ENVIRONMENT) {
1174       NodeTexEnvironment *data = node->storage;
1175       if (&data->iuser != ptr->data)
1176         continue;
1177     }
1178     else if (node->type == SH_NODE_TEX_IMAGE) {
1179       NodeTexImage *data = node->storage;
1180       if (&data->iuser != ptr->data)
1181         continue;
1182     }
1183     else
1184       continue;
1185
1186     BLI_strescape(name_esc, node->name, sizeof(name_esc));
1187     return BLI_sprintfN("nodes[\"%s\"].image_user", name_esc);
1188   }
1189
1190   return NULL;
1191 }
1192
1193 static bool rna_Node_poll(bNodeType *ntype, bNodeTree *ntree)
1194 {
1195   extern FunctionRNA rna_Node_poll_func;
1196
1197   PointerRNA ptr;
1198   ParameterList list;
1199   FunctionRNA *func;
1200   void *ret;
1201   bool visible;
1202
1203   RNA_pointer_create(NULL, ntype->ext.srna, NULL, &ptr); /* dummy */
1204   func = &rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1205
1206   RNA_parameter_list_create(&list, &ptr, func);
1207   RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1208   ntype->ext.call(NULL, &ptr, func, &list);
1209
1210   RNA_parameter_get_lookup(&list, "visible", &ret);
1211   visible = *(bool *)ret;
1212
1213   RNA_parameter_list_free(&list);
1214
1215   return visible;
1216 }
1217
1218 static bool rna_Node_poll_instance(bNode *node, bNodeTree *ntree)
1219 {
1220   extern FunctionRNA rna_Node_poll_instance_func;
1221
1222   PointerRNA ptr;
1223   ParameterList list;
1224   FunctionRNA *func;
1225   void *ret;
1226   bool visible;
1227
1228   RNA_pointer_create(NULL, node->typeinfo->ext.srna, node, &ptr); /* dummy */
1229   func = &rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */
1230
1231   RNA_parameter_list_create(&list, &ptr, func);
1232   RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1233   node->typeinfo->ext.call(NULL, &ptr, func, &list);
1234
1235   RNA_parameter_get_lookup(&list, "visible", &ret);
1236   visible = *(bool *)ret;
1237
1238   RNA_parameter_list_free(&list);
1239
1240   return visible;
1241 }
1242
1243 static bool rna_Node_poll_instance_default(bNode *node, bNodeTree *ntree)
1244 {
1245   /* use the basic poll function */
1246   return rna_Node_poll(node->typeinfo, ntree);
1247 }
1248
1249 static void rna_Node_update_reg(bNodeTree *ntree, bNode *node)
1250 {
1251   extern FunctionRNA rna_Node_update_func;
1252
1253   PointerRNA ptr;
1254   ParameterList list;
1255   FunctionRNA *func;
1256
1257   RNA_pointer_create((ID *)ntree, node->typeinfo->ext.srna, node, &ptr);
1258   func = &rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1259
1260   RNA_parameter_list_create(&list, &ptr, func);
1261   node->typeinfo->ext.call(NULL, &ptr, func, &list);
1262
1263   RNA_parameter_list_free(&list);
1264 }
1265
1266 static void rna_Node_insert_link(bNodeTree *ntree, bNode *node, bNodeLink *link)
1267 {
1268   extern FunctionRNA rna_Node_insert_link_func;
1269
1270   PointerRNA ptr;
1271   ParameterList list;
1272   FunctionRNA *func;
1273
1274   RNA_pointer_create((ID *)ntree, node->typeinfo->ext.srna, node, &ptr);
1275   func = &rna_Node_insert_link_func;
1276
1277   RNA_parameter_list_create(&list, &ptr, func);
1278   RNA_parameter_set_lookup(&list, "link", &link);
1279   node->typeinfo->ext.call(NULL, &ptr, func, &list);
1280
1281   RNA_parameter_list_free(&list);
1282 }
1283
1284 static void rna_Node_init(const bContext *C, PointerRNA *ptr)
1285 {
1286   extern FunctionRNA rna_Node_init_func;
1287
1288   bNode *node = (bNode *)ptr->data;
1289   ParameterList list;
1290   FunctionRNA *func;
1291
1292   func = &rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */
1293
1294   RNA_parameter_list_create(&list, ptr, func);
1295   node->typeinfo->ext.call((bContext *)C, ptr, func, &list);
1296
1297   RNA_parameter_list_free(&list);
1298 }
1299
1300 static void rna_Node_copy(PointerRNA *ptr, struct bNode *copynode)
1301 {
1302   extern FunctionRNA rna_Node_copy_func;
1303
1304   bNode *node = (bNode *)ptr->data;
1305   ParameterList list;
1306   FunctionRNA *func;
1307
1308   func = &rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */
1309
1310   RNA_parameter_list_create(&list, ptr, func);
1311   RNA_parameter_set_lookup(&list, "node", &copynode);
1312   node->typeinfo->ext.call(NULL, ptr, func, &list);
1313
1314   RNA_parameter_list_free(&list);
1315 }
1316
1317 static void rna_Node_free(PointerRNA *ptr)
1318 {
1319   extern FunctionRNA rna_Node_free_func;
1320
1321   bNode *node = (bNode *)ptr->data;
1322   ParameterList list;
1323   FunctionRNA *func;
1324
1325   func = &rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */
1326
1327   RNA_parameter_list_create(&list, ptr, func);
1328   node->typeinfo->ext.call(NULL, ptr, func, &list);
1329
1330   RNA_parameter_list_free(&list);
1331 }
1332
1333 static void rna_Node_draw_buttons(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1334 {
1335   extern FunctionRNA rna_Node_draw_buttons_func;
1336
1337   bNode *node = (bNode *)ptr->data;
1338   ParameterList list;
1339   FunctionRNA *func;
1340
1341   func = &rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */
1342
1343   RNA_parameter_list_create(&list, ptr, func);
1344   RNA_parameter_set_lookup(&list, "context", &C);
1345   RNA_parameter_set_lookup(&list, "layout", &layout);
1346   node->typeinfo->ext.call(C, ptr, func, &list);
1347
1348   RNA_parameter_list_free(&list);
1349 }
1350
1351 static void rna_Node_draw_buttons_ext(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1352 {
1353   extern FunctionRNA rna_Node_draw_buttons_ext_func;
1354
1355   bNode *node = (bNode *)ptr->data;
1356   ParameterList list;
1357   FunctionRNA *func;
1358
1359   func = &rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */
1360
1361   RNA_parameter_list_create(&list, ptr, func);
1362   RNA_parameter_set_lookup(&list, "context", &C);
1363   RNA_parameter_set_lookup(&list, "layout", &layout);
1364   node->typeinfo->ext.call(C, ptr, func, &list);
1365
1366   RNA_parameter_list_free(&list);
1367 }
1368
1369 static void rna_Node_draw_label(bNodeTree *ntree, bNode *node, char *label, int maxlen)
1370 {
1371   extern FunctionRNA rna_Node_draw_label_func;
1372
1373   PointerRNA ptr;
1374   ParameterList list;
1375   FunctionRNA *func;
1376   void *ret;
1377   char *rlabel;
1378
1379   func = &rna_Node_draw_label_func; /* RNA_struct_find_function(&ptr, "draw_label"); */
1380
1381   RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
1382   RNA_parameter_list_create(&list, &ptr, func);
1383   node->typeinfo->ext.call(NULL, &ptr, func, &list);
1384
1385   RNA_parameter_get_lookup(&list, "label", &ret);
1386   rlabel = *(char **)ret;
1387   BLI_strncpy(label, rlabel != NULL ? rlabel : "", maxlen);
1388
1389   RNA_parameter_list_free(&list);
1390 }
1391
1392 static bool rna_Node_is_registered_node_type(StructRNA *type)
1393 {
1394   return (RNA_struct_blender_type_get(type) != NULL);
1395 }
1396
1397 static void rna_Node_is_registered_node_type_runtime(bContext *UNUSED(C),
1398                                                      ReportList *UNUSED(reports),
1399                                                      PointerRNA *ptr,
1400                                                      ParameterList *parms)
1401 {
1402   int result = (RNA_struct_blender_type_get(ptr->type) != NULL);
1403   RNA_parameter_set_lookup(parms, "result", &result);
1404 }
1405
1406 static void rna_Node_unregister(Main *UNUSED(bmain), StructRNA *type)
1407 {
1408   bNodeType *nt = RNA_struct_blender_type_get(type);
1409
1410   if (!nt)
1411     return;
1412
1413   RNA_struct_free_extension(type, &nt->ext);
1414   RNA_struct_free(&BLENDER_RNA, type);
1415
1416   /* this also frees the allocated nt pointer, no MEM_free call needed! */
1417   nodeUnregisterType(nt);
1418
1419   /* update while blender is running */
1420   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1421 }
1422
1423 /* Generic internal registration function.
1424  * Can be used to implement callbacks for registerable RNA node subtypes.
1425  */
1426 static bNodeType *rna_Node_register_base(Main *bmain,
1427                                          ReportList *reports,
1428                                          StructRNA *basetype,
1429                                          void *data,
1430                                          const char *identifier,
1431                                          StructValidateFunc validate,
1432                                          StructCallbackFunc call,
1433                                          StructFreeFunc free)
1434 {
1435   bNodeType *nt, dummynt;
1436   bNode dummynode;
1437   PointerRNA dummyptr;
1438   FunctionRNA *func;
1439   PropertyRNA *parm;
1440   int have_function[10];
1441
1442   /* setup dummy node & node type to store static properties in */
1443   memset(&dummynt, 0, sizeof(bNodeType));
1444   /* this does some additional initialization of default values */
1445   node_type_base_custom(&dummynt, identifier, "", 0, 0);
1446
1447   memset(&dummynode, 0, sizeof(bNode));
1448   dummynode.typeinfo = &dummynt;
1449   RNA_pointer_create(NULL, basetype, &dummynode, &dummyptr);
1450
1451   /* validate the python class */
1452   if (validate(&dummyptr, data, have_function) != 0)
1453     return NULL;
1454
1455   if (strlen(identifier) >= sizeof(dummynt.idname)) {
1456     BKE_reportf(reports,
1457                 RPT_ERROR,
1458                 "Registering node class: '%s' is too long, maximum length is %d",
1459                 identifier,
1460                 (int)sizeof(dummynt.idname));
1461     return NULL;
1462   }
1463
1464   /* check if we have registered this node type before, and remove it */
1465   nt = nodeTypeFind(dummynt.idname);
1466   if (nt) {
1467     rna_Node_unregister(bmain, nt->ext.srna);
1468   }
1469
1470   /* create a new node type */
1471   nt = MEM_callocN(sizeof(bNodeType), "node type");
1472   memcpy(nt, &dummynt, sizeof(dummynt));
1473   /* make sure the node type struct is freed on unregister */
1474   nt->needs_free = 1;
1475
1476   nt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, basetype);
1477   nt->ext.data = data;
1478   nt->ext.call = call;
1479   nt->ext.free = free;
1480   RNA_struct_blender_type_set(nt->ext.srna, nt);
1481
1482   RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description);
1483   RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon);
1484
1485   func = RNA_def_function_runtime(
1486       nt->ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime);
1487   RNA_def_function_ui_description(func, "True if a registered node type");
1488   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE);
1489   parm = RNA_def_boolean(func, "result", false, "Result", "");
1490   RNA_def_function_return(func, parm);
1491
1492   /* XXX bad level call! needed to initialize the basic draw functions ... */
1493   ED_init_custom_node_type(nt);
1494
1495   nt->poll = (have_function[0]) ? rna_Node_poll : NULL;
1496   nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default;
1497   nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : NULL;
1498   nt->insert_link = (have_function[3]) ? rna_Node_insert_link : NULL;
1499   nt->initfunc_api = (have_function[4]) ? rna_Node_init : NULL;
1500   nt->copyfunc_api = (have_function[5]) ? rna_Node_copy : NULL;
1501   nt->freefunc_api = (have_function[6]) ? rna_Node_free : NULL;
1502   nt->draw_buttons = (have_function[7]) ? rna_Node_draw_buttons : NULL;
1503   nt->draw_buttons_ex = (have_function[8]) ? rna_Node_draw_buttons_ext : NULL;
1504   nt->labelfunc = (have_function[9]) ? rna_Node_draw_label : NULL;
1505
1506   /* sanitize size values in case not all have been registered */
1507   if (nt->maxwidth < nt->minwidth)
1508     nt->maxwidth = nt->minwidth;
1509   if (nt->maxheight < nt->minheight)
1510     nt->maxheight = nt->minheight;
1511   CLAMP(nt->width, nt->minwidth, nt->maxwidth);
1512   CLAMP(nt->height, nt->minheight, nt->maxheight);
1513
1514   return nt;
1515 }
1516
1517 static StructRNA *rna_Node_register(Main *bmain,
1518                                     ReportList *reports,
1519                                     void *data,
1520                                     const char *identifier,
1521                                     StructValidateFunc validate,
1522                                     StructCallbackFunc call,
1523                                     StructFreeFunc free)
1524 {
1525   bNodeType *nt = rna_Node_register_base(
1526       bmain, reports, &RNA_Node, data, identifier, validate, call, free);
1527   if (!nt)
1528     return NULL;
1529
1530   nodeRegisterType(nt);
1531
1532   /* update while blender is running */
1533   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1534
1535   return nt->ext.srna;
1536 }
1537
1538 static StructRNA *rna_ShaderNode_register(Main *bmain,
1539                                           ReportList *reports,
1540                                           void *data,
1541                                           const char *identifier,
1542                                           StructValidateFunc validate,
1543                                           StructCallbackFunc call,
1544                                           StructFreeFunc free)
1545 {
1546   bNodeType *nt = rna_Node_register_base(
1547       bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free);
1548   if (!nt)
1549     return NULL;
1550
1551   nodeRegisterType(nt);
1552
1553   /* update while blender is running */
1554   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1555
1556   return nt->ext.srna;
1557 }
1558
1559 static StructRNA *rna_CompositorNode_register(Main *bmain,
1560                                               ReportList *reports,
1561                                               void *data,
1562                                               const char *identifier,
1563                                               StructValidateFunc validate,
1564                                               StructCallbackFunc call,
1565                                               StructFreeFunc free)
1566 {
1567   bNodeType *nt = rna_Node_register_base(
1568       bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free);
1569   if (!nt)
1570     return NULL;
1571
1572   nodeRegisterType(nt);
1573
1574   /* update while blender is running */
1575   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1576
1577   return nt->ext.srna;
1578 }
1579
1580 static StructRNA *rna_TextureNode_register(Main *bmain,
1581                                            ReportList *reports,
1582                                            void *data,
1583                                            const char *identifier,
1584                                            StructValidateFunc validate,
1585                                            StructCallbackFunc call,
1586                                            StructFreeFunc free)
1587 {
1588   bNodeType *nt = rna_Node_register_base(
1589       bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free);
1590   if (!nt)
1591     return NULL;
1592
1593   nodeRegisterType(nt);
1594
1595   /* update while blender is running */
1596   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1597
1598   return nt->ext.srna;
1599 }
1600
1601 static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create)
1602 {
1603   bNode *node = ptr->data;
1604
1605   if (create && !node->prop) {
1606     IDPropertyTemplate val = {0};
1607     node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties");
1608   }
1609
1610   return node->prop;
1611 }
1612
1613 static void rna_Node_parent_set(PointerRNA *ptr,
1614                                 PointerRNA value,
1615                                 struct ReportList *UNUSED(reports))
1616 {
1617   bNode *node = ptr->data;
1618   bNode *parent = value.data;
1619
1620   if (parent) {
1621     /* XXX only Frame node allowed for now,
1622      * in the future should have a poll function or so to test possible attachment.
1623      */
1624     if (parent->type != NODE_FRAME)
1625       return;
1626
1627     /* make sure parent is not attached to the node */
1628     if (nodeAttachNodeCheck(parent, node))
1629       return;
1630   }
1631
1632   nodeDetachNode(node);
1633   if (parent) {
1634     nodeAttachNode(node, parent);
1635   }
1636 }
1637
1638 static bool rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
1639 {
1640   bNode *node = ptr->data;
1641   bNode *parent = value.data;
1642
1643   /* XXX only Frame node allowed for now,
1644    * in the future should have a poll function or so to test possible attachment.
1645    */
1646   if (parent->type != NODE_FRAME)
1647     return false;
1648
1649   /* make sure parent is not attached to the node */
1650   if (nodeAttachNodeCheck(parent, node))
1651     return false;
1652
1653   return true;
1654 }
1655
1656 static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1657 {
1658   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1659   bNode *node = (bNode *)ptr->data;
1660   ED_node_tag_update_nodetree(bmain, ntree, node);
1661 }
1662
1663 static void rna_Node_socket_value_update(ID *id, bNode *node, bContext *C)
1664 {
1665   ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id, node);
1666 }
1667
1668 static void rna_Node_select_set(PointerRNA *ptr, bool value)
1669 {
1670   bNode *node = (bNode *)ptr->data;
1671   nodeSetSelected(node, value);
1672 }
1673
1674 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
1675 {
1676   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1677   bNode *node = (bNode *)ptr->data;
1678   char oldname[sizeof(node->name)];
1679
1680   /* make a copy of the old name first */
1681   BLI_strncpy(oldname, node->name, sizeof(node->name));
1682   /* set new name */
1683   BLI_strncpy_utf8(node->name, value, sizeof(node->name));
1684
1685   nodeUniqueName(ntree, node);
1686
1687   /* fix all the animation data which may link to this */
1688   BKE_animdata_fix_paths_rename_all(NULL, "nodes", oldname, node->name);
1689 }
1690
1691 static bNodeSocket *rna_Node_inputs_new(ID *id,
1692                                         bNode *node,
1693                                         Main *bmain,
1694                                         ReportList *reports,
1695                                         const char *type,
1696                                         const char *name,
1697                                         const char *identifier)
1698 {
1699   /* Adding an input to a group node is not working,
1700    * simpler to add it to its underlying nodetree. */
1701   if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id != NULL) {
1702     return rna_NodeTree_inputs_new((bNodeTree *)node->id, bmain, reports, type, name);
1703   }
1704
1705   bNodeTree *ntree = (bNodeTree *)id;
1706   bNodeSocket *sock;
1707
1708   sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name);
1709
1710   if (sock == NULL) {
1711     BKE_report(reports, RPT_ERROR, "Unable to create socket");
1712   }
1713   else {
1714     ntreeUpdateTree(bmain, ntree);
1715     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1716   }
1717
1718   return sock;
1719 }
1720
1721 static bNodeSocket *rna_Node_outputs_new(ID *id,
1722                                          bNode *node,
1723                                          Main *bmain,
1724                                          ReportList *reports,
1725                                          const char *type,
1726                                          const char *name,
1727                                          const char *identifier)
1728 {
1729   /* Adding an output to a group node is not working,
1730    * simpler to add it to its underlying nodetree. */
1731   if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id != NULL) {
1732     return rna_NodeTree_outputs_new((bNodeTree *)node->id, bmain, reports, type, name);
1733   }
1734
1735   bNodeTree *ntree = (bNodeTree *)id;
1736   bNodeSocket *sock;
1737
1738   sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name);
1739
1740   if (sock == NULL) {
1741     BKE_report(reports, RPT_ERROR, "Unable to create socket");
1742   }
1743   else {
1744     ntreeUpdateTree(bmain, ntree);
1745     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1746   }
1747
1748   return sock;
1749 }
1750
1751 static void rna_Node_socket_remove(
1752     ID *id, bNode *node, Main *bmain, ReportList *reports, bNodeSocket *sock)
1753 {
1754   bNodeTree *ntree = (bNodeTree *)id;
1755
1756   if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
1757     BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1758   }
1759   else {
1760     nodeRemoveSocket(ntree, node, sock);
1761
1762     ntreeUpdateTree(bmain, ntree);
1763     WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1764   }
1765 }
1766
1767 static void rna_Node_inputs_clear(ID *id, bNode *node, Main *bmain)
1768 {
1769   bNodeTree *ntree = (bNodeTree *)id;
1770   bNodeSocket *sock, *nextsock;
1771
1772   for (sock = node->inputs.first; sock; sock = nextsock) {
1773     nextsock = sock->next;
1774     nodeRemoveSocket(ntree, node, sock);
1775   }
1776
1777   ntreeUpdateTree(bmain, ntree);
1778   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1779 }
1780
1781 static void rna_Node_outputs_clear(ID *id, bNode *node, Main *bmain)
1782 {
1783   bNodeTree *ntree = (bNodeTree *)id;
1784   bNodeSocket *sock, *nextsock;
1785
1786   for (sock = node->outputs.first; sock; sock = nextsock) {
1787     nextsock = sock->next;
1788     nodeRemoveSocket(ntree, node, sock);
1789   }
1790
1791   ntreeUpdateTree(bmain, ntree);
1792   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1793 }
1794
1795 static void rna_Node_inputs_move(ID *id, bNode *node, Main *bmain, int from_index, int to_index)
1796 {
1797   bNodeTree *ntree = (bNodeTree *)id;
1798   bNodeSocket *sock;
1799
1800   if (from_index == to_index)
1801     return;
1802   if (from_index < 0 || to_index < 0)
1803     return;
1804
1805   sock = BLI_findlink(&node->inputs, from_index);
1806   if (to_index < from_index) {
1807     bNodeSocket *nextsock = BLI_findlink(&node->inputs, to_index);
1808     if (nextsock) {
1809       BLI_remlink(&node->inputs, sock);
1810       BLI_insertlinkbefore(&node->inputs, nextsock, sock);
1811     }
1812   }
1813   else {
1814     bNodeSocket *prevsock = BLI_findlink(&node->inputs, to_index);
1815     if (prevsock) {
1816       BLI_remlink(&node->inputs, sock);
1817       BLI_insertlinkafter(&node->inputs, prevsock, sock);
1818     }
1819   }
1820
1821   ntreeUpdateTree(bmain, ntree);
1822   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1823 }
1824
1825 static void rna_Node_outputs_move(ID *id, bNode *node, Main *bmain, int from_index, int to_index)
1826 {
1827   bNodeTree *ntree = (bNodeTree *)id;
1828   bNodeSocket *sock;
1829
1830   if (from_index == to_index)
1831     return;
1832   if (from_index < 0 || to_index < 0)
1833     return;
1834
1835   sock = BLI_findlink(&node->outputs, from_index);
1836   if (to_index < from_index) {
1837     bNodeSocket *nextsock = BLI_findlink(&node->outputs, to_index);
1838     if (nextsock) {
1839       BLI_remlink(&node->outputs, sock);
1840       BLI_insertlinkbefore(&node->outputs, nextsock, sock);
1841     }
1842   }
1843   else {
1844     bNodeSocket *prevsock = BLI_findlink(&node->outputs, to_index);
1845     if (prevsock) {
1846       BLI_remlink(&node->outputs, sock);
1847       BLI_insertlinkafter(&node->outputs, prevsock, sock);
1848     }
1849   }
1850
1851   ntreeUpdateTree(bmain, ntree);
1852   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1853 }
1854
1855 static void rna_Node_width_range(
1856     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1857 {
1858   bNode *node = ptr->data;
1859   *min = *softmin = node->typeinfo->minwidth;
1860   *max = *softmax = node->typeinfo->maxwidth;
1861 }
1862
1863 static void rna_Node_height_range(
1864     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1865 {
1866   bNode *node = ptr->data;
1867   *min = *softmin = node->typeinfo->minheight;
1868   *max = *softmax = node->typeinfo->maxheight;
1869 }
1870
1871 static void rna_Node_dimensions_get(PointerRNA *ptr, float *value)
1872 {
1873   bNode *node = ptr->data;
1874   value[0] = node->totr.xmax - node->totr.xmin;
1875   value[1] = node->totr.ymax - node->totr.ymin;
1876 }
1877
1878 /* ******** Node Socket ******** */
1879
1880 static void rna_NodeSocket_draw(
1881     bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
1882 {
1883   extern FunctionRNA rna_NodeSocket_draw_func;
1884
1885   bNodeSocket *sock = (bNodeSocket *)ptr->data;
1886   ParameterList list;
1887   FunctionRNA *func;
1888
1889   func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1890
1891   RNA_parameter_list_create(&list, ptr, func);
1892   RNA_parameter_set_lookup(&list, "context", &C);
1893   RNA_parameter_set_lookup(&list, "layout", &layout);
1894   RNA_parameter_set_lookup(&list, "node", node_ptr);
1895   RNA_parameter_set_lookup(&list, "text", &text);
1896   sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1897
1898   RNA_parameter_list_free(&list);
1899 }
1900
1901 static void rna_NodeSocket_draw_color(bContext *C,
1902                                       PointerRNA *ptr,
1903                                       PointerRNA *node_ptr,
1904                                       float *r_color)
1905 {
1906   extern FunctionRNA rna_NodeSocket_draw_color_func;
1907
1908   bNodeSocket *sock = (bNodeSocket *)ptr->data;
1909   ParameterList list;
1910   FunctionRNA *func;
1911   void *ret;
1912
1913   func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1914
1915   RNA_parameter_list_create(&list, ptr, func);
1916   RNA_parameter_set_lookup(&list, "context", &C);
1917   RNA_parameter_set_lookup(&list, "node", node_ptr);
1918   sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1919
1920   RNA_parameter_get_lookup(&list, "color", &ret);
1921   copy_v4_v4(r_color, (float *)ret);
1922
1923   RNA_parameter_list_free(&list);
1924 }
1925
1926 static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type)
1927 {
1928   bNodeSocketType *st = RNA_struct_blender_type_get(type);
1929   if (!st)
1930     return;
1931
1932   RNA_struct_free_extension(type, &st->ext_socket);
1933   RNA_struct_free(&BLENDER_RNA, type);
1934
1935   nodeUnregisterSocketType(st);
1936
1937   /* update while blender is running */
1938   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1939 }
1940
1941 static StructRNA *rna_NodeSocket_register(Main *UNUSED(bmain),
1942                                           ReportList *reports,
1943                                           void *data,
1944                                           const char *identifier,
1945                                           StructValidateFunc validate,
1946                                           StructCallbackFunc call,
1947                                           StructFreeFunc free)
1948 {
1949   bNodeSocketType *st, dummyst;
1950   bNodeSocket dummysock;
1951   PointerRNA dummyptr;
1952   int have_function[2];
1953
1954   /* setup dummy socket & socket type to store static properties in */
1955   memset(&dummyst, 0, sizeof(bNodeSocketType));
1956
1957   memset(&dummysock, 0, sizeof(bNodeSocket));
1958   dummysock.typeinfo = &dummyst;
1959   RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr);
1960
1961   /* validate the python class */
1962   if (validate(&dummyptr, data, have_function) != 0)
1963     return NULL;
1964
1965   if (strlen(identifier) >= sizeof(dummyst.idname)) {
1966     BKE_reportf(reports,
1967                 RPT_ERROR,
1968                 "Registering node socket class: '%s' is too long, maximum length is %d",
1969                 identifier,
1970                 (int)sizeof(dummyst.idname));
1971     return NULL;
1972   }
1973
1974   /* check if we have registered this socket type before */
1975   st = nodeSocketTypeFind(dummyst.idname);
1976   if (!st) {
1977     /* create a new node socket type */
1978     st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
1979     memcpy(st, &dummyst, sizeof(dummyst));
1980
1981     nodeRegisterSocketType(st);
1982   }
1983
1984   /* if RNA type is already registered, unregister first */
1985   if (st->ext_socket.srna) {
1986     StructRNA *srna = st->ext_socket.srna;
1987     RNA_struct_free_extension(srna, &st->ext_socket);
1988     RNA_struct_free(&BLENDER_RNA, srna);
1989   }
1990   st->ext_socket.srna = RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket);
1991   st->ext_socket.data = data;
1992   st->ext_socket.call = call;
1993   st->ext_socket.free = free;
1994   RNA_struct_blender_type_set(st->ext_socket.srna, st);
1995
1996   /* XXX bad level call! needed to initialize the basic draw functions ... */
1997   ED_init_custom_node_socket_type(st);
1998
1999   st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL;
2000   st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL;
2001
2002   /* update while blender is running */
2003   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2004
2005   return st->ext_socket.srna;
2006 }
2007
2008 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
2009 {
2010   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2011
2012   if (sock->typeinfo->ext_socket.srna)
2013     return sock->typeinfo->ext_socket.srna;
2014   else
2015     return &RNA_NodeSocket;
2016 }
2017
2018 static char *rna_NodeSocket_path(PointerRNA *ptr)
2019 {
2020   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2021   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2022   bNode *node;
2023   int socketindex;
2024   char name_esc[sizeof(node->name) * 2];
2025
2026   if (!nodeFindNode(ntree, sock, &node, &socketindex))
2027     return NULL;
2028
2029   BLI_strescape(name_esc, node->name, sizeof(name_esc));
2030
2031   if (sock->in_out == SOCK_IN) {
2032     return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", name_esc, socketindex);
2033   }
2034   else {
2035     return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", name_esc, socketindex);
2036   }
2037 }
2038
2039 static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create)
2040 {
2041   bNodeSocket *sock = ptr->data;
2042
2043   if (create && !sock->prop) {
2044     IDPropertyTemplate val = {0};
2045     sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties");
2046   }
2047
2048   return sock->prop;
2049 }
2050
2051 static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
2052 {
2053   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2054   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2055   bNode *node;
2056   PointerRNA r_ptr;
2057
2058   nodeFindNode(ntree, sock, &node, NULL);
2059
2060   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr);
2061   return r_ptr;
2062 }
2063
2064 static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2065 {
2066   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2067   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2068   bNode *node;
2069   if (nodeFindNode(ntree, sock, &node, NULL)) {
2070     ED_node_tag_update_nodetree(bmain, ntree, node);
2071   }
2072 }
2073
2074 static bool rna_NodeSocket_is_output_get(PointerRNA *ptr)
2075 {
2076   bNodeSocket *sock = ptr->data;
2077   return sock->in_out == SOCK_OUT;
2078 }
2079
2080 static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
2081 {
2082   bNodeSocket *sock = ptr->data;
2083   sock->limit = (value == 0 ? 0xFFF : value);
2084 }
2085
2086 static void rna_NodeSocket_hide_set(PointerRNA *ptr, bool value)
2087 {
2088   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2089
2090   /* don't hide linked sockets */
2091   if (sock->flag & SOCK_IN_USE)
2092     return;
2093
2094   if (value)
2095     sock->flag |= SOCK_HIDDEN;
2096   else
2097     sock->flag &= ~SOCK_HIDDEN;
2098 }
2099
2100 static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr)
2101 {
2102   extern FunctionRNA rna_NodeSocketInterface_draw_func;
2103
2104   bNodeSocket *stemp = (bNodeSocket *)ptr->data;
2105   ParameterList list;
2106   FunctionRNA *func;
2107
2108   if (!stemp->typeinfo)
2109     return;
2110
2111   func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
2112
2113   RNA_parameter_list_create(&list, ptr, func);
2114   RNA_parameter_set_lookup(&list, "context", &C);
2115   RNA_parameter_set_lookup(&list, "layout", &layout);
2116   stemp->typeinfo->ext_interface.call(C, ptr, func, &list);
2117
2118   RNA_parameter_list_free(&list);
2119 }
2120
2121 static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color)
2122 {
2123   extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
2124
2125   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2126   ParameterList list;
2127   FunctionRNA *func;
2128   void *ret;
2129
2130   if (!sock->typeinfo)
2131     return;
2132
2133   func =
2134       &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
2135
2136   RNA_parameter_list_create(&list, ptr, func);
2137   RNA_parameter_set_lookup(&list, "context", &C);
2138   sock->typeinfo->ext_interface.call(C, ptr, func, &list);
2139
2140   RNA_parameter_get_lookup(&list, "color", &ret);
2141   copy_v4_v4(r_color, (float *)ret);
2142
2143   RNA_parameter_list_free(&list);
2144 }
2145
2146 static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree,
2147                                                         bNodeSocket *stemp,
2148                                                         StructRNA *data_srna)
2149 {
2150   extern FunctionRNA rna_NodeSocketInterface_register_properties_func;
2151
2152   PointerRNA ptr;
2153   ParameterList list;
2154   FunctionRNA *func;
2155
2156   if (!stemp->typeinfo)
2157     return;
2158
2159   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2160   /* RNA_struct_find_function(&ptr, "register_properties"); */
2161   func = &rna_NodeSocketInterface_register_properties_func;
2162
2163   RNA_parameter_list_create(&list, &ptr, func);
2164   RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna);
2165   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2166
2167   RNA_parameter_list_free(&list);
2168 }
2169
2170 static void rna_NodeSocketInterface_init_socket(
2171     bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path)
2172 {
2173   extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
2174
2175   PointerRNA ptr, node_ptr, sock_ptr;
2176   ParameterList list;
2177   FunctionRNA *func;
2178
2179   if (!stemp->typeinfo)
2180     return;
2181
2182   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2183   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2184   RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2185   /* RNA_struct_find_function(&ptr, "init_socket"); */
2186   func = &rna_NodeSocketInterface_init_socket_func;
2187
2188   RNA_parameter_list_create(&list, &ptr, func);
2189   RNA_parameter_set_lookup(&list, "node", &node_ptr);
2190   RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2191   RNA_parameter_set_lookup(&list, "data_path", &data_path);
2192   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2193
2194   RNA_parameter_list_free(&list);
2195 }
2196
2197 static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree,
2198                                                 bNodeSocket *stemp,
2199                                                 bNode *node,
2200                                                 bNodeSocket *sock)
2201 {
2202   extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
2203
2204   PointerRNA ptr, node_ptr, sock_ptr;
2205   ParameterList list;
2206   FunctionRNA *func;
2207
2208   if (!stemp->typeinfo)
2209     return;
2210
2211   RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2212   RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2213   RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2214   /* RNA_struct_find_function(&ptr, "from_socket"); */
2215   func = &rna_NodeSocketInterface_from_socket_func;
2216
2217   RNA_parameter_list_create(&list, &ptr, func);
2218   RNA_parameter_set_lookup(&list, "node", &node_ptr);
2219   RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2220   stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2221
2222   RNA_parameter_list_free(&list);
2223 }
2224
2225 static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type)
2226 {
2227   bNodeSocketType *st = RNA_struct_blender_type_get(type);
2228   if (!st)
2229     return;
2230
2231   RNA_struct_free_extension(type, &st->ext_interface);
2232
2233   RNA_struct_free(&BLENDER_RNA, type);
2234
2235   /* update while blender is running */
2236   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2237 }
2238
2239 static StructRNA *rna_NodeSocketInterface_register(Main *UNUSED(bmain),
2240                                                    ReportList *UNUSED(reports),
2241                                                    void *data,
2242                                                    const char *identifier,
2243                                                    StructValidateFunc validate,
2244                                                    StructCallbackFunc call,
2245                                                    StructFreeFunc free)
2246 {
2247   bNodeSocketType *st, dummyst;
2248   bNodeSocket dummysock;
2249   PointerRNA dummyptr;
2250   int have_function[5];
2251
2252   /* setup dummy socket & socket type to store static properties in */
2253   memset(&dummyst, 0, sizeof(bNodeSocketType));
2254
2255   memset(&dummysock, 0, sizeof(bNodeSocket));
2256   dummysock.typeinfo = &dummyst;
2257   RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr);
2258
2259   /* validate the python class */
2260   if (validate(&dummyptr, data, have_function) != 0)
2261     return NULL;
2262
2263   /* check if we have registered this socket type before */
2264   st = nodeSocketTypeFind(dummyst.idname);
2265   if (st) {
2266     /* basic socket type registered by a socket class before. */
2267   }
2268   else {
2269     /* create a new node socket type */
2270     st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
2271     memcpy(st, &dummyst, sizeof(dummyst));
2272
2273     nodeRegisterSocketType(st);
2274   }
2275
2276   /* if RNA type is already registered, unregister first */
2277   if (st->ext_interface.srna) {
2278     StructRNA *srna = st->ext_interface.srna;
2279     RNA_struct_free_extension(srna, &st->ext_interface);
2280     RNA_struct_free(&BLENDER_RNA, srna);
2281   }
2282   st->ext_interface.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface);
2283   st->ext_interface.data = data;
2284   st->ext_interface.call = call;
2285   st->ext_interface.free = free;
2286   RNA_struct_blender_type_set(st->ext_interface.srna, st);
2287
2288   st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL;
2289   st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL;
2290   st->interface_register_properties = (have_function[2]) ?
2291                                           rna_NodeSocketInterface_register_properties :
2292                                           NULL;
2293   st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL;
2294   st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL;
2295
2296   /* update while blender is running */
2297   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2298
2299   return st->ext_interface.srna;
2300 }
2301
2302 static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr)
2303 {
2304   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2305
2306   if (sock->typeinfo && sock->typeinfo->ext_interface.srna)
2307     return sock->typeinfo->ext_interface.srna;
2308   else
2309     return &RNA_NodeSocketInterface;
2310 }
2311
2312 static char *rna_NodeSocketInterface_path(PointerRNA *ptr)
2313 {
2314   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2315   bNodeSocket *sock = (bNodeSocket *)ptr->data;
2316   int socketindex;
2317
2318   socketindex = BLI_findindex(&ntree->inputs, sock);
2319   if (socketindex != -1)
2320     return BLI_sprintfN("inputs[%d]", socketindex);
2321
2322   socketindex = BLI_findindex(&ntree->outputs, sock);
2323   if (socketindex != -1)
2324     return BLI_sprintfN("outputs[%d]", socketindex);
2325
2326   return NULL;
2327 }
2328
2329 static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create)
2330 {
2331   bNodeSocket *sock = ptr->data;
2332
2333   if (create && !sock->prop) {
2334     IDPropertyTemplate val = {0};
2335     sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties");
2336   }
2337
2338   return sock->prop;
2339 }
2340
2341 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2342 {
2343   bNodeTree *ntree = ptr->id.data;
2344   bNodeSocket *stemp = ptr->data;
2345
2346   if (!stemp->typeinfo)
2347     return;
2348
2349   ntree->update |= NTREE_UPDATE_GROUP;
2350   ntreeUpdateTree(bmain, ntree);
2351
2352   ED_node_tag_update_nodetree(bmain, ntree, NULL);
2353 }
2354
2355 /* ******** Standard Node Socket Base Types ******** */
2356
2357 static void rna_NodeSocketStandard_draw(ID *id,
2358                                         bNodeSocket *sock,
2359                                         struct bContext *C,
2360                                         struct uiLayout *layout,
2361                                         PointerRNA *nodeptr,
2362                                         const char *text)
2363 {
2364   PointerRNA ptr;
2365   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2366   sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
2367 }
2368
2369 static void rna_NodeSocketStandard_draw_color(
2370     ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float *r_color)
2371 {
2372   PointerRNA ptr;
2373   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2374   sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
2375 }
2376
2377 static void rna_NodeSocketInterfaceStandard_draw(ID *id,
2378                                                  bNodeSocket *sock,
2379                                                  struct bContext *C,
2380                                                  struct uiLayout *layout)
2381 {
2382   PointerRNA ptr;
2383   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2384   sock->typeinfo->interface_draw(C, layout, &ptr);
2385 }
2386
2387 static void rna_NodeSocketInterfaceStandard_draw_color(ID *id,
2388                                                        bNodeSocket *sock,
2389                                                        struct bContext *C,
2390                                                        float *r_color)
2391 {
2392   PointerRNA ptr;
2393   RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2394   sock->typeinfo->interface_draw_color(C, &ptr, r_color);
2395 }
2396
2397 static void rna_NodeSocketStandard_float_range(
2398     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2399 {
2400   bNodeSocket *sock = ptr->data;
2401   bNodeSocketValueFloat *dval = sock->default_value;
2402   int subtype = sock->typeinfo->subtype;
2403
2404   if (dval->max < dval->min) {
2405     dval->max = dval->min;
2406   }
2407
2408   *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
2409   *max = FLT_MAX;
2410   *softmin = dval->min;
2411   *softmax = dval->max;
2412 }
2413
2414 static void rna_NodeSocketStandard_int_range(
2415     PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
2416 {
2417   bNodeSocket *sock = ptr->data;
2418   bNodeSocketValueInt *dval = sock->default_value;
2419   int subtype = sock->typeinfo->subtype;
2420
2421   if (dval->max < dval->min) {
2422     dval->max = dval->min;
2423   }
2424
2425   *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
2426   *max = INT_MAX;
2427   *softmin = dval->min;
2428   *softmax = dval->max;
2429 }
2430
2431 static void rna_NodeSocketStandard_vector_range(
2432     PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2433 {
2434   bNodeSocket *sock = ptr->data;
2435   bNodeSocketValueVector *dval = sock->default_value;
2436
2437   if (dval->max < dval->min) {
2438     dval->max = dval->min;
2439   }
2440
2441   *min = -FLT_MAX;
2442   *max = FLT_MAX;
2443   *softmin = dval->min;
2444   *softmax = dval->max;
2445 }
2446
2447 /* using a context update function here, to avoid searching the node if possible */
2448 static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr)
2449 {
2450   bNode *node;
2451
2452   /* default update */
2453   rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
2454
2455   /* try to use node from context, faster */
2456   node = CTX_data_pointer_get(C, "node").data;
2457   if (!node) {
2458     bNodeTree *ntree = ptr->id.data;
2459     bNodeSocket *sock = ptr->data;
2460
2461     /* fall back to searching node in the tree */
2462     nodeFindNode(ntree, sock, &node, NULL);
2463   }
2464 }
2465
2466 /* ******** Node Types ******** */
2467
2468 static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
2469 {
2470   bNodeSocketTemplate *stemp = ptr->data;
2471   strcpy(value, stemp->name);
2472 }
2473
2474 static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
2475 {
2476   bNodeSocketTemplate *stemp = ptr->data;
2477   return strlen(stemp->name);
2478 }
2479
2480 static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
2481 {
2482   bNodeSocketTemplate *stemp = ptr->data;
2483   strcpy(value, stemp->identifier);
2484 }
2485
2486 static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
2487 {
2488   bNodeSocketTemplate *stemp = ptr->data;
2489   return strlen(stemp->identifier);
2490 }
2491
2492 static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
2493 {
2494   bNodeSocketTemplate *stemp = ptr->data;
2495   return stemp->type;
2496 }
2497
2498 static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
2499 {
2500   bNodeType *ntype = RNA_struct_blender_type_get(srna);
2501   if (ntype && ntype->inputs) {
2502     bNodeSocketTemplate *stemp = ntype->inputs;
2503     int i = 0;
2504     while (i < index && stemp->type >= 0) {
2505       ++i;
2506       ++stemp;
2507     }
2508     if (i == index && stemp->type >= 0) {
2509       PointerRNA ptr;
2510       RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2511       return ptr;
2512     }
2513   }
2514   return PointerRNA_NULL;
2515 }
2516
2517 static PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
2518 {
2519   bNodeType *ntype = RNA_struct_blender_type_get(srna);
2520   if (ntype && ntype->outputs) {
2521     bNodeSocketTemplate *stemp = ntype->outputs;
2522     int i = 0;
2523     while (i < index && stemp->type >= 0) {
2524       ++i;
2525       ++stemp;
2526     }
2527     if (i == index && stemp->type >= 0) {
2528       PointerRNA ptr;
2529       RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2530       return ptr;
2531     }
2532   }
2533   return PointerRNA_NULL;
2534 }
2535
2536 static bool rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
2537 {
2538   bNodeType *ntype = RNA_struct_blender_type_get(srna);
2539   return ntype && (!ntype->poll || ntype->poll(ntype, ntree));
2540 }
2541
2542 static bool rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
2543 {
2544   bNodeType *ntype = node->typeinfo;
2545   if (ntype->poll_instance) {
2546     return ntype->poll_instance(node, ntree);
2547   }
2548   else {
2549     /* fall back to basic poll function */
2550     return !ntype->poll || ntype->poll(ntype, ntree);
2551   }
2552 }
2553
2554 static void rna_NodeInternal_update(ID *id, bNode *node)
2555 {
2556   bNodeTree *ntree = (bNodeTree *)id;
2557   if (node->typeinfo->updatefunc)
2558     node->typeinfo->updatefunc(ntree, node);
2559 }
2560
2561 static void rna_NodeInternal_draw_buttons(ID *id,
2562                                           bNode *node,
2563                                           struct bContext *C,
2564                                           struct uiLayout *layout)
2565 {
2566   if (node->typeinfo->draw_buttons) {
2567     PointerRNA ptr;
2568     RNA_pointer_create(id, &RNA_Node, node, &ptr);
2569     node->typeinfo->draw_buttons(layout, C, &ptr);
2570   }
2571 }
2572
2573 static void rna_NodeInternal_draw_buttons_ext(ID *id,
2574                                               bNode *node,
2575                                               struct bContext *C,
2576                                               struct uiLayout *layout)
2577 {
2578   if (node->typeinfo->draw_buttons_ex) {
2579     PointerRNA ptr;
2580     RNA_pointer_create(id, &RNA_Node, node, &ptr);
2581     node->typeinfo->draw_buttons_ex(layout, C, &ptr);
2582   }
2583   else if (node->typeinfo->draw_buttons) {
2584     PointerRNA ptr;
2585     RNA_pointer_create(id, &RNA_Node, node, &ptr);
2586     node->typeinfo->draw_buttons(layout, C, &ptr);
2587   }
2588 }
2589
2590 static StructRNA *rna_NodeCustomGroup_register(Main *bmain,
2591                                                ReportList *reports,
2592                                                void *data,
2593                                                const char *identifier,
2594                                                StructValidateFunc validate,
2595                                                StructCallbackFunc call,
2596                                                StructFreeFunc free)
2597 {
2598   bNodeType *nt = rna_Node_register_base(
2599       bmain, reports, &RNA_NodeCustomGroup, data, identifier, validate, call, free);
2600   if (!nt)
2601     return NULL;
2602
2603   /* this updates the group node instance from the tree's interface */
2604   nt->group_update_func = node_group_update;
2605
2606   nodeRegisterType(nt);
2607
2608   /* update while blender is running */
2609   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2610
2611   return nt->ext.srna;
2612 }
2613
2614 static StructRNA *rna_ShaderNodeCustomGroup_register(Main *bmain,
2615                                                      ReportList *reports,
2616                                                      void *data,
2617                                                      const char *identifier,
2618                                                      StructValidateFunc validate,
2619                                                      StructCallbackFunc call,
2620                                                      StructFreeFunc free)
2621 {
2622   bNodeType *nt = rna_Node_register_base(
2623       bmain, reports, &RNA_ShaderNodeCustomGroup, data, identifier, validate, call, free);
2624
2625   if (!nt)
2626     return NULL;
2627
2628   nt->group_update_func = node_group_update;
2629   nt->type = NODE_CUSTOM_GROUP;
2630
2631   register_node_type_sh_custom_group(nt);
2632
2633   nodeRegisterType(nt);
2634
2635   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2636
2637   return nt->ext.srna;
2638 }
2639
2640 static StructRNA *rna_CompositorNodeCustomGroup_register(Main *bmain,
2641                                                          ReportList *reports,
2642                                                          void *data,
2643                                                          const char *identifier,
2644                                                          StructValidateFunc validate,
2645                                                          StructCallbackFunc call,
2646                                                          StructFreeFunc free)
2647 {
2648   bNodeType *nt = rna_Node_register_base(
2649       bmain, reports, &RNA_CompositorNodeCustomGroup, data, identifier, validate, call, free);
2650   if (!nt)
2651     return NULL;
2652
2653   nt->group_update_func = node_group_update;
2654   nt->type = NODE_CUSTOM_GROUP;
2655
2656   register_node_type_cmp_custom_group(nt);
2657
2658   nodeRegisterType(nt);
2659
2660   WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2661
2662   return nt->ext.srna;
2663 }
2664
2665 static void rna_CompositorNode_tag_need_exec(bNode *node)
2666 {
2667   node->need_exec = true;
2668 }
2669
2670 static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2671 {
2672   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2673   bNode *node = (bNode *)ptr->data;
2674
2675   ED_node_tag_update_nodetree(bmain, ntree, node);
2676   WM_main_add_notifier(NC_IMAGE, NULL);
2677 }
2678
2679 static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2680 {
2681   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2682   bNode *node = (bNode *)ptr->data;
2683
2684   if (node->id)
2685     ntreeUpdateTree(bmain, (bNodeTree *)node->id);
2686
2687   ED_node_tag_update_nodetree(bmain, ntree, node);
2688 }
2689
2690 static void rna_NodeGroup_node_tree_set(PointerRNA *ptr,
2691                                         const PointerRNA value,
2692                                         struct ReportList *UNUSED(reports))
2693 {
2694   bNodeTree *ntree = ptr->id.data;
2695   bNode *node = ptr->data;
2696   bNodeTree *ngroup = value.data;
2697
2698   if (nodeGroupPoll(ntree, ngroup)) {
2699     if (node->id)
2700       id_us_min(node->id);
2701     if (ngroup)
2702       id_us_plus(&ngroup->id);
2703
2704     node->id = &ngroup->id;
2705   }
2706 }
2707
2708 static bool rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
2709 {
2710   bNodeTree *ntree = ptr->id.data;
2711   bNodeTree *ngroup = value.data;
2712
2713   /* only allow node trees of the same type as the group node's tree */
2714   if (ngroup->type != ntree->type)
2715     return false;
2716
2717   return nodeGroupPoll(ntree, ngroup);
2718 }
2719
2720 static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr)
2721 {
2722   bNode *node = ptr->data;
2723   bNodeTree *ngroup = (bNodeTree *)node->id;
2724
2725   if (ngroup) {
2726     StructRNA *srna = ntreeInterfaceTypeGet(ngroup, true);
2727     if (srna)
2728       return srna;
2729   }
2730   return &RNA_PropertyGroup;
2731 }
2732
2733 static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr)
2734 {
2735   bNodeTree *ntree = ptr->id.data;
2736
2737   if (ntree) {
2738     StructRNA *srna = ntreeInterfaceTypeGet(ntree, true);
2739     if (srna)
2740       return srna;
2741   }
2742   return &RNA_PropertyGroup;
2743 }
2744
2745 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
2746 {
2747   bNode *node = (bNode *)ptr->data;
2748   NodeChroma *chroma = node->storage;
2749
2750   chroma->t1 = value;
2751 }
2752
2753 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
2754 {
2755   bNode *node = (bNode *)ptr->data;
2756   NodeChroma *chroma = node->storage;
2757
2758   chroma->t2 = value;
2759 }
2760
2761 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
2762 {
2763   bNode *node = (bNode *)ptr->data;
2764   NodeChroma *chroma = node->storage;
2765
2766   chroma->t1 = value;
2767 }
2768
2769 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
2770 {
2771   bNode *node = (bNode *)ptr->data;
2772   NodeChroma *chroma = node->storage;
2773
2774   chroma->t2 = value;
2775 }
2776
2777 /* Button Set Funcs for Matte Nodes */
2778 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
2779 {
2780   bNode *node = (bNode *)ptr->data;
2781   NodeChroma *chroma = node->storage;
2782
2783   chroma->t1 = value;
2784
2785   if (value < chroma->t2)
2786     chroma->t2 = value;
2787 }
2788
2789 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
2790 {
2791   bNode *node = (bNode *)ptr->data;
2792   NodeChroma *chroma = node->storage;
2793
2794   if (value > chroma->t1)
2795     value = chroma->t1;
2796
2797   chroma->t2 = value;
2798 }
2799
2800 static void rna_Node_scene_set(PointerRNA *ptr,
2801                                PointerRNA value,
2802                                struct ReportList *UNUSED(reports))
2803 {
2804   bNode *node = (bNode *)ptr->data;
2805
2806   if (node->id) {
2807     id_us_min(node->id);
2808     node->id = NULL;
2809   }
2810
2811   node->id = value.data;
2812
2813   id_us_plus(node->id);
2814 }
2815
2816 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2817 {
2818   bNode *node = (bNode *)ptr->data;
2819   Image *ima = (Image *)node->id;
2820   ImageUser *iuser = node->storage;
2821
2822   BKE_image_multilayer_index(ima->rr, iuser);
2823   BKE_image_signal(bmain, ima, iuser, IMA_SIGNAL_SRC_CHANGE);
2824
2825   rna_Node_update(bmain, scene, ptr);
2826
2827   if (scene->nodetree != NULL) {
2828     ntreeCompositUpdateRLayers(scene->nodetree);
2829   }
2830 }
2831
2832 static const EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
2833 {
2834   EnumPropertyItem *item = NULL;
2835   EnumPropertyItem tmp = {0};
2836   int i = 0, totitem = 0;
2837
2838   while (rl) {
2839     tmp.identifier = rl->name;
2840     /* Little trick: using space char instead empty string
2841      * makes the item selectable in the dropdown. */
2842     if (rl->name[0] == '\0')
2843       tmp.name = " ";
2844     else
2845       tmp.name = rl->name;
2846     tmp.value = i++;
2847     RNA_enum_item_add(&item, &totitem, &tmp);
2848     rl = rl->next;
2849   }
2850
2851   RNA_enum_item_end(&item, &totitem);
2852
2853   return item;
2854 }
2855
2856 static const EnumPropertyItem *rna_Node_image_layer_itemf(bContext *UNUSED(C),
2857                                                           PointerRNA *ptr,
2858                                                           PropertyRNA *UNUSED(prop),
2859                                                           bool *r_free)
2860 {
2861   bNode *node = (bNode *)ptr->data;
2862   Image *ima = (Image *)node->id;
2863   const EnumPropertyItem *item = NULL;
2864   RenderLayer *rl;
2865
2866   if (ima == NULL || ima->rr == NULL) {
2867     *r_free = false;
2868     return DummyRNA_NULL_items;
2869   }
2870
2871   rl = ima->rr->layers.first;
2872   item = renderresult_layers_add_enum(rl);
2873
2874   *r_free = true;
2875
2876   return item;
2877 }
2878
2879 static bool rna_Node_image_has_layers_get(PointerRNA *ptr)
2880 {
2881   bNode *node = (bNode *)ptr->data;
2882   Image *ima = (Image *)node->id;
2883
2884   if (!ima || !(ima->rr))
2885     return 0;
2886
2887   return RE_layers_have_name(ima->rr);
2888 }
2889
2890 static bool rna_Node_image_has_views_get(PointerRNA *ptr)
2891 {
2892   bNode *node = (bNode *)ptr->data;
2893   Image *ima = (Image *)node->id;
2894
2895   if (!ima || !(ima->rr))
2896     return 0;
2897
2898   return BLI_listbase_count_at_most(&ima->rr->views, 2) > 1;
2899 }
2900
2901 static const EnumPropertyItem *renderresult_views_add_enum(RenderView *rv)
2902 {
2903   EnumPropertyItem *item = NULL;
2904   EnumPropertyItem tmp = {0, "ALL", 0, "All", ""};
2905   int i = 1, totitem = 0;
2906
2907   /* option to use all views */
2908   RNA_enum_item_add(&item, &totitem, &tmp);
2909
2910   while (rv) {
2911     tmp.identifier = rv->name;
2912     /* Little trick: using space char instead empty string
2913      * makes the item selectable in the dropdown. */
2914     if (rv->name[0] == '\0')
2915       tmp.name = " ";
2916     else
2917       tmp.name = rv->name;
2918     tmp.value = i++;
2919     RNA_enum_item_add(&item, &totitem, &tmp);
2920     rv = rv->next;
2921   }
2922
2923   RNA_enum_item_end(&item, &totitem);
2924
2925   return item;
2926 }
2927
2928 static const EnumPropertyItem *rna_Node_image_view_itemf(bContext *UNUSED(C),
2929                                                          PointerRNA *ptr,
2930                                                          PropertyRNA *UNUSED(prop),
2931                                                          bool *r_free)
2932 {
2933   bNode *node = (bNode *)ptr->data;
2934   Image *ima = (Image *)node->id;
2935   const EnumPropertyItem *item = NULL;
2936   RenderView *rv;
2937
2938   if (ima == NULL || ima->rr == NULL) {
2939     *r_free = false;
2940     return DummyRNA_NULL_items;
2941   }
2942
2943   rv = ima->rr->views.first;
2944   item = renderresult_views_add_enum(rv);
2945
2946   *r_free = true;
2947
2948   return item;
2949 }
2950
2951 static const EnumPropertyItem *rna_Node_view_layer_itemf(bContext *UNUSED(C),
2952                                                          PointerRNA *ptr,
2953                                                          PropertyRNA *UNUSED(prop),
2954                                                          bool *r_free)
2955 {
2956   bNode *node = (bNode *)ptr->data;
2957   Scene *sce = (Scene *)node->id;
2958   const EnumPropertyItem *item = NULL;
2959   RenderLayer *rl;
2960
2961   if (sce == NULL) {
2962     *r_free = false;
2963     return DummyRNA_NULL_items;
2964   }
2965
2966   rl = sce->view_layers.first;
2967   item = renderresult_layers_add_enum(rl);
2968
2969   *r_free = true;
2970
2971   return item;
2972 }
2973
2974 static void rna_Node_view_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2975 {
2976   rna_Node_update(bmain, scene, ptr);
2977   if (scene->nodetree != NULL) {
2978     ntreeCompositUpdateRLayers(scene->nodetree);
2979   }
2980 }
2981
2982 static const EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C),
2983                                                       PointerRNA *ptr,
2984                                                       PropertyRNA *UNUSED(prop),
2985                                                       bool *r_free)
2986 {
2987   bNode *node = (bNode *)ptr->data;
2988   EnumPropertyItem *item = NULL;
2989   EnumPropertyItem tmp = {0};
2990   int totitem = 0;
2991
2992   switch (node->custom1) {
2993     case CMP_NODE_CHANNEL_MATTE_CS_RGB:
2994       tmp.identifier = "R";
2995       tmp.name = "R";
2996       tmp.value = 1;
2997       RNA_enum_item_add(&item, &totitem, &tmp);
2998       tmp.identifier = "G";
2999       tmp.name = "G";
3000       tmp.value = 2;
3001       RNA_enum_item_add(&item, &totitem, &tmp);
3002       tmp.identifier = "B";
3003       tmp.name = "B";
3004       tmp.value = 3;
3005       RNA_enum_item_add(&item, &totitem, &tmp);
3006       break;
3007     case CMP_NODE_CHANNEL_MATTE_CS_HSV:
3008       tmp.identifier = "H";
3009       tmp.name = "H";
3010       tmp.value = 1;
3011       RNA_enum_item_add(&item, &totitem, &tmp);
3012       tmp.identifier = "S";
3013       tmp.name = "S";
3014       tmp.value = 2;
3015       RNA_enum_item_add(&item, &totitem, &tmp);
3016       tmp.identifier = "V";
3017       tmp.name = "V";
3018       tmp.value = 3;
3019       RNA_enum_item_add(&item, &totitem, &tmp);
3020       break;
3021     case CMP_NODE_CHANNEL_MATTE_CS_YUV:
3022       tmp.identifier = "Y";
3023       tmp.name = "Y";
3024       tmp.value = 1;
3025       RNA_enum_item_add(&item, &totitem, &tmp);
3026       tmp.identifier = "G";
3027       tmp.name = "U";
3028       tmp.value = 2;
3029       RNA_enum_item_add(&item, &totitem, &tmp);
3030       tmp.identifier = "V";
3031       tmp.name = "V";
3032       tmp.value = 3;
3033       RNA_enum_item_add(&item, &totitem, &tmp);
3034       break;
3035     case CMP_NODE_CHANNEL_MATTE_CS_YCC:
3036       tmp.identifier = "Y";
3037       tmp.name = "Y";
3038       tmp.value = 1;
3039       RNA_enum_item_add(&item, &totitem, &tmp);
3040       tmp.identifier = "CB";
3041       tmp.name = "Cr";
3042       tmp.value = 2;
3043       RNA_enum_item_add(&item, &totitem, &tmp);
3044       tmp.identifier = "CR";
3045       tmp.name = "Cb";
3046       tmp.value = 3;
3047       RNA_enum_item_add(&item, &totitem, &tmp);
3048       break;
3049     default:
3050       return DummyRNA_NULL_items;
3051   }
3052
3053   RNA_enum_item_end(&item, &totitem);
3054   *r_free = true;
3055
3056   return item;
3057 }
3058
3059 static void rna_Image_Node_update_id(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
3060 {
3061   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
3062   bNode *node = (bNode *)ptr->data;
3063
3064   node->update |= NODE_UPDATE_ID;
3065   nodeUpdate(ntree, node); /* to update image node sockets */
3066 }
3067
3068 static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3069 {
3070   bNode *node = ptr->data;
3071   BKE_texture_mapping_init(node->storage);
3072   rna_Node_update(bmain, scene, ptr);
3073 }
3074
3075 static void rna_NodeOutputFile_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
3076 {
3077   bNode *node = ptr->data;
3078   rna_iterator_listbase_begin(iter, &node->inputs, NULL);
3079 }
3080
3081 static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *iter)
3082 {
3083   PointerRNA ptr;
3084   bNodeSocket *sock = rna_iterator_listbase_get(iter);
3085   RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotFile, sock->storage, &ptr);
3086   return ptr;
3087 }
3088
3089 static void rna_NodeColorBalance_update_lgg(Main *bmain, Scene *scene, PointerRNA *ptr)
3090 {
3091   ntreeCompositColorBalanceSyncFromLGG(ptr->id.data, ptr->data);
3092   rna_Node_update(bmain, scene, ptr);
3093 }
3094
3095 static void rna_NodeColorBalance_update_cdl(Main *bmain, Scene *scene, PointerRNA *ptr)
3096 {
3097   ntreeCompositColorBalanceSyncFromCDL(ptr->id.data, ptr->data);
3098   rna_Node_update(bmain, scene, ptr);
3099 }
3100
3101 static void rna_NodeCryptomatte_matte_get(PointerRNA *ptr, char *value)
3102 {
3103   bNode *node = (bNode *)ptr->data;
3104   NodeCryptomatte *nc = node->storage;
3105
3106   strcpy(value, (nc->matte_id) ? nc->matte_id : "");
3107 }
3108
3109 static int rna_NodeCryptomatte_matte_length(PointerRNA *ptr)
3110 {
3111   bNode *node = (bNode *)ptr->data;
3112   NodeCryptomatte *nc = node->storage;
3113
3114   return (nc->matte_id) ? strlen(nc->matte_id) : 0;
3115 }
3116
3117 static void rna_NodeCryptomatte_matte_set(PointerRNA *ptr, const char *value)
3118 {
3119   bNode *node = (bNode *)ptr->data;
3120   NodeCryptomatte *nc = node->storage;
3121
3122   if (nc->matte_id)
3123     MEM_freeN(nc->matte_id);
3124
3125   if (value && value[0])
3126     nc->matte_id = BLI_strdup(value);
3127   else
3128     nc->matte_id = NULL;
3129 }
3130
3131 static void rna_NodeCryptomatte_update_add(Main *bmain, Scene *scene, PointerRNA *ptr)
3132 {
3133   ntreeCompositCryptomatteSyncFromAdd(ptr->id.data, ptr->data);
3134   rna_Node_update(bmain, scene, ptr);
3135 }
3136
3137 static void rna_NodeCryptomatte_update_remove(Main *bmain, Scene *scene, PointerRNA *ptr)
3138 {
3139   ntreeCompositCryptomatteSyncFromRemove(ptr->id.data, ptr->data);
3140   rna_Node_update(bmain, scene, ptr);
3141 }
3142
3143 /* ******** Node Socket Types ******** */
3144
3145 static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter)
3146 {
3147   PointerRNA ptr;
3148   bNodeSocket *sock = rna_iterator_listbase_get(iter);
3149   RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotLayer, sock->storage, &ptr);
3150   return ptr;
3151 }
3152
3153 static int rna_NodeOutputFileSocket_find_node(bNodeTree *ntree,
3154                                               NodeImageMultiFileSocket *data,
3155                                               bNode **nodep,
3156                                               bNodeSocket **sockp)
3157 {
3158   bNode *node;
3159   bNodeSocket *sock;
3160
3161   for (node = ntree->nodes.first; node; node = node->next) {
3162     for (sock = node->inputs.first; sock; sock = sock->next) {
3163       NodeImageMultiFileSocket *sockdata = sock->storage;
3164       if (sockdata == data) {
3165         *nodep = node;
3166         *sockp = sock;
3167         return 1;
3168       }
3169     }
3170   }
3171
3172   *nodep = NULL;
3173   *sockp = NULL;
3174   return 0;
3175 }
3176
3177 static void rna_NodeOutputFileSlotFile_path_set(PointerRNA *ptr, const char *value)
3178 {
3179   bNodeTree *ntree = ptr->id.data;
3180   NodeImageMultiFileSocket *sockdata = ptr->data;
3181   bNode *node;
3182   bNodeSocket *sock;
3183
3184   if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
3185     ntreeCompositOutputFileSetPath(node, sock, value);
3186   }
3187 }
3188
3189 static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *value)
3190 {
3191   bNodeTree *ntree = ptr->id.data;
3192   NodeImageMultiFileSocket *sockdata = ptr->data;
3193   bNode *node;
3194   bNodeSocket *sock;
3195
3196   if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
3197     ntreeCompositOutputFileSetLayer(node, sock, value);
3198   }
3199 }
3200
3201 static bNodeSocket *rna_NodeOutputFile_slots_new(
3202     ID *id, bNode *node, bContext *C, ReportList *UNUSED(reports), const char *name)
3203 {
3204   bNodeTree *ntree = (bNodeTree *)id;
3205   Scene *scene = CTX_data_scene(C);
3206   ImageFormatData *im_format = NULL;
3207   bNodeSocket *sock;
3208   if (scene)
3209     im_format = &scene->r.im_format;
3210
3211   sock = ntreeCompositOutputFileAddSocket(ntree, node, name, im_format);
3212
3213   ntreeUpdateTree(CTX_data_main(C), ntree);
3214   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
3215
3216   return sock;
3217 }
3218
3219 static void rna_ShaderNodeTexIES_mode_set(PointerRNA *ptr, int value)
3220 {
3221   bNode *node = (bNode *)ptr->data;
3222   NodeShaderTexIES *nss = node->storage;
3223
3224   if (nss->mode != value) {
3225     nss->mode = value;
3226     nss->filepath[0] = '\0';
3227
3228     /* replace text datablock by filepath */
3229     if (node->id) {
3230       Text *text = (Text *)node->id;
3231
3232       if (value == NODE_IES_EXTERNAL && text->name) {
3233         BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
3234         BLI_path_rel(nss->filepath, BKE_main_blendfile_path_from_global());
3235       }
3236
3237       id_us_min(node->id);
3238       node->id = NULL;
3239     }
3240   }
3241 }
3242
3243 static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value)
3244 {
3245   bNode *node = (bNode *)ptr->data;
3246   NodeShaderScript *nss = node->storage;
3247
3248   if (nss->mode != value) {
3249     nss->mode = value;
3250     nss->filepath[0] = '\0';
3251     nss->flag &= ~NODE_SCRIPT_AUTO_UPDATE;
3252
3253     /* replace text data-block by filepath */
3254     if (node->id) {
3255       Text *text = (Text *)node->id;
3256
3257       if (value == NODE_SCRIPT_EXTERNAL && text->name) {
3258         BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
3259         BLI_path_rel(nss->filepath, BKE_main_blendfile_path_from_global());
3260       }
3261
3262       id_us_min(node->id);
3263       node->id = NULL;
3264     }
3265
3266     /* remove any bytecode */
3267     if (nss->bytecode) {
3268       MEM_freeN(nss->bytecode);
3269       nss->bytecode = NULL;
3270     }
3271
3272     nss->bytecode_hash[0] = '\0';
3273   }
3274 }
3275
3276 static void rna_ShaderNodeScript_bytecode_get(PointerRNA *ptr, char *value)
3277 {
3278   bNode *node = (bNode *)ptr->data;
3279   NodeShaderScript *nss = node->storage;
3280
3281   strcpy(value, (nss->bytecode) ? nss->bytecode : "");
3282 }
3283
3284 static int rna_ShaderNodeScript_bytecode_length(PointerRNA *ptr)
3285 {
3286   bNode *node = (bNode *)ptr->data;
3287   NodeShaderScript *nss = node->storage;
3288
3289   return (nss->bytecode) ? strlen(nss->bytecode) : 0;
3290 }
3291
3292 static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value)
3293 {
3294   bNode *node = (bNode *)ptr->data;
3295   NodeShaderScript *nss = node->storage;
3296
3297   if (nss->bytecode)
3298     MEM_freeN(nss->bytecode);
3299
3300   if (value && value[0])
3301     nss->bytecode = BLI_strdup(value);
3302   else
3303     nss->bytecode = NULL;
3304 }
3305
3306 static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3307 {
3308   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
3309   bNode *node = (bNode *)ptr->data;
3310   RenderEngineType *engine_type = RE_engines_find(scene->r.engine);
3311
3312   if (engine_type && engine_type->update_script_node) {
3313     /* auto update node */
3314     RenderEngine *engine = RE_engine_create(engine_type);
3315     engine_type->update_script_node(engine, ntree, node);
3316     RE_engine_free(engine);
3317   }
3318
3319   ED_node_tag_update_nodetree(bmain, ntree, node);
3320 }
3321
3322 static void rna_ShaderNode_socket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3323 {
3324   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
3325   bNode *node = (bNode *)ptr->data;
3326
3327   nodeUpdate(ntree, node);
3328   rna_Node_update(bmain, scene, ptr);
3329 }
3330
3331 static void rna_CompositorNodeScale_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3332 {
3333   bNodeTree *ntree = (bNodeTree *)ptr->id.data;
3334   bNode *node = (bNode *)ptr->data;
3335
3336   nodeUpdate(ntree, node);
3337   rna_Node_update(bmain, scene, ptr);
3338 }
3339
3340 static PointerRNA rna_ShaderNodePointDensity_psys_get(PointerRNA *ptr)
3341 {
3342   bNode *node = ptr->data;
3343   NodeShaderTexPointDensity *shader_point_density = node->storage;
3344   Object *ob = (Object *)node->id;
3345   ParticleSystem *psys = NULL;
3346   PointerRNA value;
3347
3348   if (ob && shader_point_density->particle_system) {
3349     psys = BLI_findlink(&ob->particlesystem, shader_point_density->particle_system - 1);
3350   }
3351
3352   RNA_pointer_create(&ob->id, &RNA_ParticleSystem, psys, &value);
3353   return value;
3354 }
3355
3356 static void rna_ShaderNodePointDensity_psys_set(PointerRNA *ptr,
3357                                                 PointerRNA value,
3358                                                 struct ReportList *UNUSED(reports))
3359 {
3360   bNode *node = ptr->data;
3361   NodeShaderTexPointDensity *shader_point_density = node->storage;
3362   Object *ob = (Object *)node->id;
3363
3364   if (ob && value.id.data == ob) {
3365     shader_point_density->particle_system = BLI_findindex(&ob->particlesystem, value.data) + 1;
3366   }
3367   else {
3368     shader_point_density->particle_system = 0;
3369   }
3370 }
3371
3372 static int point_density_particle_color_source_from_shader(
3373     NodeShaderTexPointDensity *shader_point_density)
3374 {
3375   switch (shader_point_density->color_source) {
3376     case SHD_POINTDENSITY_COLOR_PARTAGE:
3377       return TEX_PD_COLOR_PARTAGE;
3378     case SHD_POINTDENSITY_COLOR_PARTSPEED:
3379       return TEX_PD_COLOR_PARTSPEED;
3380     case SHD_POINTDENSITY_COLOR_PARTVEL:
3381       return TEX_PD_COLOR_PARTVEL;
3382     default:
3383       BLI_assert(!"Unknown color source");
3384       return TEX_PD_COLOR_CONSTANT;
3385   }
3386 }
3387
3388 static int point_density_vertex_color_source_from_shader(
3389     NodeShaderTexPointDensity *shader_point_density)
3390 {
3391   switch (shader_point_density->ob_color_source) {
3392     case SHD_POINTDENSITY_COLOR_VERTCOL:
3393       return TEX_PD_COLOR_VERTCOL;
3394     case SHD_POINTDENSITY_COLOR_VERTWEIGHT:
3395       return TEX_PD_COLOR_VERTWEIGHT;
3396     case SHD_POINTDENSITY_COLOR_VERTNOR:
3397       return TEX_PD_COLOR_VERTNOR;
3398     default:
3399       BLI_assert(!"Unknown color source");
3400       return TEX_PD_COLOR_CONSTANT;
3401   }
3402 }
3403
3404 void rna_ShaderNodePointDensity_density_cache(bNode *self, Depsgraph *depsgraph)
3405 {
3406   NodeShaderTexPointDensity *shader_point_density = self->storage;
3407   PointDensity *pd = &shader_point_density->pd;
3408
3409   if (depsgraph == NULL) {
3410     return;
3411   }
3412
3413   /* Make sure there's no cached data. */
3414   BKE_texture_pointdensity_free_data(pd);
3415   RE_point_density_free(pd);
3416
3417   /* Create PointDensity structure from node for sampling. */
3418   BKE_texture_pointdensity_init_data(pd);
3419   pd->object = (Object *)self->id;
3420   pd->radius = shader_point_density->radius;
3421   if (shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_PSYS) {
3422     pd->source = TEX_PD_PSYS;
3423     pd->psys = shader_point_density->particle_system;
3424     pd->psys_cache_space = TEX_PD_OBJECTSPACE;
3425     pd->color_source = point_density_particle_color_source_from_shader(shader_point_density);
3426   }
3427   else {
3428     BLI_assert(shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_OBJECT);
3429     pd->source = TEX_PD_OBJECT;
3430     pd->ob_cache_space = TEX_PD_OBJECTSPACE;
3431     pd->ob_color_source = point_density_vertex_color_source_from_shader(shader_point_density);
3432     BLI_strncpy(pd->vertex_attribute_name,
3433                 shader_point_density->vertex_attribute_name,
3434                 sizeof(pd->vertex_attribute_name));
3435   }
3436
3437   /* Store resolution, so it can be changed in the UI. */
3438   shader_point_density->cached_resolution = shader_point_density->resolution;
3439
3440   /* Single-threaded sampling of the voxel domain. */
3441   RE_point_density_cache(depsgraph, pd);
3442 }
3443
3444 void rna_ShaderNodePointDensity_density_calc(bNode *self,
3445                                              Depsgraph *depsgraph,
3446                                              int *length,
3447                                              float **values)
3448 {
3449   NodeShaderTexPointDensity *shader_point_density = self->storage;
3450   PointDensity *pd = &shader_point_density->pd;
3451   const int resolution = shader_point_density->cached_resolution;
3452
3453   if (depsgraph == NULL) {
3454     *length = 0;
3455     return;
3456   }
3457
3458   /* TODO(sergey): Will likely overflow, but how to pass size_t via RNA? */
3459   *length = 4 * resolution * resolution * resolution;
3460
3461   if (*values == NULL) {
3462     *values = MEM_mallocN(sizeof(float) * (*length), "point density dynamic array");
3463   }
3464
3465   /* Single-threaded sampling of the voxel domain. */
3466   RE_point_density_sample(depsgraph, pd, resolution, *values);
3467
3468   /* We're done, time to clean up. */
3469   BKE_texture_pointdensity_free_data(pd);
3470   memset(pd, 0, sizeof(*pd));
3471   shader_point_density->cached_resolution = 0.0f;
3472 }
3473
3474 void rna_ShaderNodePointDensity_density_minmax(bNode *self,
3475                                                Depsgraph *depsgraph,
3476                                                float r_min[3],
3477                                                float r_max[3])
3478 {
3479   NodeShaderTexPointDensity *shader_point_density = self->storage;
3480   PointDensity *pd = &shader_point_density->pd;
3481
3482   if (depsgraph == NULL) {
3483     zero_v3(r_min);
3484     zero_v3(r_max);
3485     return;
3486   }
3487
3488   RE_point_density_minmax(depsgraph, pd, r_min, r_max);
3489 }
3490
3491 #else
3492
3493 static const EnumPropertyItem prop_image_layer_items[] = {
3494     {0, "PLACEHOLDER", 0, "Placeholder", ""},
3495     {0, NULL, 0, NULL, NULL},
3496 };
3497
3498 static const EnumPropertyItem prop_image_view_items[] = {
3499     {0, "ALL", 0, "All", ""},
3500     {0, NULL, 0, NULL, NULL},
3501 };
3502
3503 static const EnumPropertyItem prop_view_layer_items[] = {
3504     {0, "PLACEHOLDER", 0, "Placeholder", ""},
3505     {0, NULL, 0, NULL, NULL},
3506 };
3507
3508 static const EnumPropertyItem prop_tri_channel_items[] = {
3509     {1, "R", 0, "R", ""},
3510     {2, "G", 0, "G", ""},
3511     {3, "B", 0, "B", ""},
3512     {0, NULL, 0, NULL, NULL},
3513 };
3514
3515 static const EnumPropertyItem node_flip_items[] = {
3516     {0, "X", 0, "Flip X", ""},
3517     {1, "Y", 0, "Flip Y", ""},
3518     {2, "XY", 0, "Flip X & Y", ""},
3519     {0, NULL, 0, NULL, NULL},
3520 };
3521
3522 static const EnumPropertyItem node_ycc_items[] = {
3523     {0, "ITUBT601", 0, "ITU 601", ""},
3524     {1, "ITUBT709", 0, "ITU 709", ""},
3525     {2, "JFIF", 0, "Jpeg", ""},
3526     {0, NULL, 0, NULL, NULL},
3527 };
3528
3529 static const EnumPropertyItem node_glossy_items[] = {
3530     {SHD_GLOSSY_SHARP, "SHARP", 0, "Sharp", ""},
3531     {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
3532     {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
3533     {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
3534     {SHD_GLOSSY_MULTI_GGX, "MULTI_GGX", 0, "Multiscatter GGX", ""},
3535     {0, NULL, 0, NULL, NULL},
3536 };
3537
3538 static const EnumPropertyItem node_anisotropic_items[] = {
3539     {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
3540     {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
3541     {SHD_GLOSSY_MULTI_GGX, "MULTI_GGX", 0, "Multiscatter GGX", ""},
3542     {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
3543     {0, NULL, 0, NULL, NULL},
3544 };
3545
3546 static const EnumPropertyItem node_glass_items[] = {
3547     {SHD_GLOSSY_SHARP, "SHARP", 0, "Sharp", ""},
3548     {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
3549     {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
3550     {SHD_GLOSSY_MULTI_GGX, "MULTI_GGX", 0, "Multiscatter GGX", ""},
3551     {0, NULL, 0, NULL, NULL},
3552 };
3553
3554 static const EnumPropertyItem node_refraction_items[] = {
3555     {SHD_GLOSSY_SHARP, "SHARP", 0, "Sharp", ""},
3556     {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
3557     {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
3558     {0, NULL, 0, NULL, NULL},
3559 };
3560
3561 static const EnumPropertyItem node_toon_items[] = {
3562     {SHD_TOON_DIFFUSE, "DIFFUSE", 0, "Diffuse", ""},
3563     {SHD_TOON_GLOSSY, "GLOSSY", 0, "Glossy", ""},
3564     {0, NULL, 0, NULL, NULL},
3565 };
3566
3567 static const EnumPropertyItem node_hair_items[] = {
3568     {SHD_HAIR_REFLECTION, "Reflection", 0, "Reflection", ""},
3569     {SHD_HAIR_TRANSMISSION, "Transmission", 0, "Transmission", ""},
3570     {0, NULL, 0, NULL, NULL},
3571 };
3572
3573 static const EnumPropertyItem node_principled_hair_items[] = {
3574     {SHD_PRINCIPLED_HAIR_DIRECT_ABSORPTION,
3575      "ABSORPTION",
3576      0,
3577      "Absorption coefficient",
3578      "Directly set the absorption coefficient sigma_a (this is not the most intuitive way to "
3579      "color hair)"},
3580     {SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION,
3581      "MELANIN",
3582      0,
3583      "Melanin concentration",
3584      "Define the melanin concentrations below to get the most realistic-looking hair"
3585      "(you can get the concentrations for different types of hair online)"},
3586     {SHD_PRINCIPLED_HAIR_REFLECTANCE,
3587      "COLOR",
3588      0,
3589      "Direct coloring",
3590      "Choose the color of your preference, and the shader will approximate the absorption "
3591      "coefficient to render lookalike hair"},
3592     {0, NULL, 0, NULL, NULL},
3593 };
3594
3595 static const EnumPropertyItem node_script_mode_items[] = {
3596     {NODE_SCRIPT_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text data-block"},
3597     {NODE_SCRIPT_EXTERNAL, "EXTERNAL", 0, "External", "Use external .osl or .oso file"},
3598     {0, NULL, 0, NULL, NULL},
3599 };
3600
3601 static EnumPropertyItem node_ies_mode_items[] = {
3602     {NODE_IES_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text datablock"},
3603     {NODE_IES_EXTERNAL, "EXTERNAL", 0, "External", "Use external .ies file"},
3604     {0, NULL, 0, NULL, NULL},
3605 };
3606
3607 static const EnumPropertyItem node_principled_distribution_items[] = {
3608     {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
3609     {SHD_GLOSSY_MULTI_GGX, "MULTI_GGX", 0, "Multiscatter GGX", ""},
3610     {0, NULL, 0, NULL, NULL},
3611 };
3612
3613 static const EnumPropertyItem node_subsurface_method_items[] = {
3614     {SHD_SUBSURFACE_BURLEY,
3615      "BURLEY",
3616      0,
3617      "Christensen-Burley",
3618      "Approximation to physically based volume scattering"},
3619     {SHD_SUBSURFACE_RANDOM_WALK,
3620      "RANDOM_WALK",
3621      0,
3622      "Random Walk",
3623      "Volumetric approximation to physically based volume scattering"},
3624     {0, NULL, 0, NULL, NULL}};
3625
3626 /* -- Common nodes ---------------------------------------------------------- */
3627
3628 static void def_group_input(StructRNA *srna)
3629 {
3630   PropertyRNA *prop;
3631
3632   prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3633   RNA_def_property_pointer_funcs(
3634       prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
3635   RNA_def_property_struct_type(prop, "PropertyGroup");
3636   RNA_def_property_flag(prop, PROP_IDPROPERTY);
3637   RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3638 }
3639
3640 static void def_group_output(StructRNA *srna)
3641 {
3642   PropertyRNA *prop;
3643
3644   prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3645   RNA_def_property_pointer_funcs(
3646       prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
3647   RNA_def_property_struct_type(prop, "PropertyGroup");
3648   RNA_def_property_flag(prop, PROP_IDPROPERTY);
3649   RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3650
3651   prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
3652   RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_DO_OUTPUT);
3653   RNA_def_property_ui_text(
3654       prop, "Active Output", "True if this node is used as the active group output");
3655   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3656 }
3657
3658 static void def_group(StructRNA *srna)
3659 {
3660   PropertyRNA *prop;
3661
3662   prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
3663   RNA_def_property_pointer_sdna(prop, NULL, "id");
3664   RNA_def_property_struct_type(prop, "NodeTree");
3665   RNA_def_property_pointer_funcs(
3666       prop, NULL, "rna_NodeGroup_node_tree_set", NULL, "rna_NodeGroup_node_tree_poll");
3667   RNA_def_property_flag(prop, PROP_EDITABLE);
3668   RNA_def_property_ui_text(prop, "Node Tree", "");
3669   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update");
3670
3671   prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3672   RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroup_interface_typef", NULL);
3673   RNA_def_property_struct_type(prop, "PropertyGroup");
3674   RNA_def_property_flag(prop, PROP_IDPROPERTY);
3675   RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3676 }
3677
3678 static void def_custom_group(BlenderRNA *brna,
3679                              const char *struct_name,
3680                              const char *base_name,
3681                              const char *ui_name,
3682                              const char *ui_desc,
3683                              const char *reg_func)
3684 {
3685   StructRNA *srna;
3686
3687   srna = RNA_def_struct(brna, struct_name, base_name);
3688   RNA_def_struct_ui_text(srna, ui_name, ui_desc);
3689   RNA_def_struct_sdna(srna, "bNode");
3690
3691   RNA_def_struct_register_funcs(srna, reg_func, "rna_Node_unregister", NULL);
3692
3693   def_group(srna);
3694 }
3695
3696 static void def_frame(StructRNA *srna)
3697 {
3698   PropertyRNA *prop;
3699
3700   prop = RNA_def_property(srna, "text", PROP_POINTER, PROP_NONE);
3701   RNA_def_property_pointer_sdna(prop, NULL, "id");
3702   RNA_def_property_struct_type(prop, "Text");
3703   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
3704   RNA_def_property_ui_text(prop, "Text", "");
3705   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3706
3707   RNA_def_struct_sdna_from(srna, "NodeFrame", "storage");
3708   RNA_def_struct_translation_context(srna, BLT_I18NCONTEXT_ID_NODETREE);
3709
3710   prop = RNA_def_property(srna, "shrink", PROP_BOOLEAN, PROP_NONE);
3711   RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_FRAME_SHRINK);
3712   RNA_def_property_ui_text(prop, "Shrink", "Shrink the frame to minimal bounding box");
3713   RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
3714
3715