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