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