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