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