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