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