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