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