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