Merging r46495 through r46557 from trunk into soc-2011-tomato
[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
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "RNA_access.h"
32 #include "RNA_define.h"
33 #include "RNA_enum_types.h"
34
35 #include "rna_internal.h"
36 #include "rna_internal_types.h"
37
38 #include "BLI_listbase.h"
39
40 #include "DNA_material_types.h"
41 #include "DNA_mesh_types.h"
42 #include "DNA_node_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_scene_types.h"
45 #include "DNA_texture_types.h"
46
47 #include "BKE_animsys.h"
48 #include "BKE_main.h"
49 #include "BKE_node.h"
50 #include "BKE_image.h"
51 #include "BKE_texture.h"
52
53 #include "BLI_math.h"
54 #include "BLI_utildefines.h"
55
56 #include "WM_types.h"
57
58 #include "MEM_guardedalloc.h"
59
60 EnumPropertyItem nodetree_type_items[] = {
61         {NTREE_SHADER,          "SHADER",               ICON_MATERIAL,          "Shader",               "Shader nodes"  },
62         {NTREE_TEXTURE,         "TEXTURE",              ICON_TEXTURE,           "Texture",              "Texture nodes"         },
63         {NTREE_COMPOSIT,        "COMPOSITING",  ICON_RENDERLAYERS,      "Compositing",  "Compositing nodes"     },
64         {0, NULL, 0, NULL, NULL}
65 };
66
67
68 EnumPropertyItem node_socket_type_items[] = {
69         {SOCK_FLOAT,   "VALUE",     0,    "Value",     ""},
70         {SOCK_VECTOR,  "VECTOR",    0,    "Vector",    ""},
71         {SOCK_RGBA,    "RGBA",      0,    "RGBA",      ""},
72         {SOCK_SHADER,  "SHADER",    0,    "Shader",    ""},
73         {SOCK_BOOLEAN, "BOOLEAN",   0,    "Boolean",   ""},
74         {SOCK_MESH,    "MESH",      0,    "Mesh",      ""},
75         {SOCK_INT,     "INT",       0,    "Int",       ""},
76         {0, NULL, 0, NULL, NULL}};
77
78 EnumPropertyItem node_math_items[] = {
79         { 0, "ADD",          0, "Add",          ""},
80         { 1, "SUBTRACT",     0, "Subtract",     ""},
81         { 2, "MULTIPLY",     0, "Multiply",     ""},
82         { 3, "DIVIDE",       0, "Divide",       ""},
83         { 4, "SINE",         0, "Sine",         ""},
84         { 5, "COSINE",       0, "Cosine",       ""},
85         { 6, "TANGENT",      0, "Tangent",      ""},
86         { 7, "ARCSINE",      0, "Arcsine",      ""},
87         { 8, "ARCCOSINE",    0, "Arccosine",    ""},
88         { 9, "ARCTANGENT",   0, "Arctangent",   ""},
89         {10, "POWER",        0, "Power",        ""},
90         {11, "LOGARITHM",    0, "Logarithm",    ""},
91         {12, "MINIMUM",      0, "Minimum",      ""},
92         {13, "MAXIMUM",      0, "Maximum",      ""},
93         {14, "ROUND",        0, "Round",        ""},
94         {15, "LESS_THAN",    0, "Less Than",    ""},
95         {16, "GREATER_THAN", 0, "Greater Than", ""},
96         {0, NULL, 0, NULL, NULL}};
97
98 EnumPropertyItem node_vec_math_items[] = {
99         {0, "ADD",           0, "Add",           ""},
100         {1, "SUBTRACT",      0, "Subtract",      ""},
101         {2, "AVERAGE",       0, "Average",       ""},
102         {3, "DOT_PRODUCT",   0, "Dot Product",   ""},
103         {4, "CROSS_PRODUCT", 0, "Cross Product", ""},
104         {5, "NORMALIZE",     0, "Normalize",     ""},
105         {0, NULL, 0, NULL, NULL}};
106
107 EnumPropertyItem node_filter_items[] = {
108         {0, "SOFTEN",  0, "Soften",  ""},
109         {1, "SHARPEN", 0, "Sharpen", ""},
110         {2, "LAPLACE", 0, "Laplace", ""},
111         {3, "SOBEL",   0, "Sobel",   ""},
112         {4, "PREWITT", 0, "Prewitt", ""},
113         {5, "KIRSCH",  0, "Kirsch",  ""},
114         {6, "SHADOW",  0, "Shadow",  ""},
115         {0, NULL, 0, NULL, NULL}};
116
117 EnumPropertyItem prop_noise_basis_items[] = {
118         {SHD_NOISE_PERLIN, "PERLIN", 0, "Perlin", ""},
119         {SHD_NOISE_VORONOI_F1, "VORONOI_F1", 0, "Voronoi F1", ""},
120         {SHD_NOISE_VORONOI_F2, "VORONOI_F2", 0, "Voronoi F2", ""},
121         {SHD_NOISE_VORONOI_F3, "VORONOI_F3", 0, "Voronoi F3", ""},
122         {SHD_NOISE_VORONOI_F4, "VORONOI_F4", 0, "Voronoi F4", ""},
123         {SHD_NOISE_VORONOI_F2_F1, "VORONOI_F2_F1", 0, "Voronoi F2-F1", ""},
124         {SHD_NOISE_VORONOI_CRACKLE, "VORONOI_CRACKLE", 0, "Voronoi Crackle", ""},
125         {SHD_NOISE_CELL_NOISE, "CELL_NOISE", 0, "Cell Noise", ""},
126         {0, NULL, 0, NULL, NULL}};
127
128 EnumPropertyItem prop_noise_type_items[] = {
129         {SHD_NOISE_SOFT, "SOFT", 0, "Soft", ""},
130         {SHD_NOISE_HARD, "HARD", 0, "Hard", ""},
131         {0, NULL, 0, NULL, NULL}};
132
133 #if 0
134 EnumPropertyItem prop_wave_items[] = {
135         {SHD_WAVE_SINE, "SINE", 0, "Sine", "Use a sine wave to produce bands"},
136         {SHD_WAVE_SAW, "SAW", 0, "Saw", "Use a saw wave to produce bands"},
137         {SHD_WAVE_TRI, "TRI", 0, "Tri", "Use a triangle wave to produce bands"},
138         {0, NULL, 0, NULL, NULL}};
139 #endif
140
141 /* Add any new socket value subtype here.
142  * When adding a new subtype here, make sure you also add it
143  * to the subtype definitions in DNA_node_types.h.
144  * This macro is used by the RNA and the internal converter functions
145  * to define all socket subtypes. The SUBTYPE macro must be defined
146  * before using this macro, and undefined afterwards.
147  */
148 #define NODE_DEFINE_SUBTYPES_INT \
149 SUBTYPE(INT, Int, NONE, None) \
150 SUBTYPE(INT, Int, UNSIGNED, Unsigned)
151
152 #define NODE_DEFINE_SUBTYPES_FLOAT \
153 SUBTYPE(FLOAT, Float, NONE, None) \
154 SUBTYPE(FLOAT, Float, UNSIGNED, Unsigned) \
155 SUBTYPE(FLOAT, Float, PERCENTAGE, Percentage) \
156 SUBTYPE(FLOAT, Float, FACTOR, Factor) \
157 SUBTYPE(FLOAT, Float, ANGLE, Angle) \
158 SUBTYPE(FLOAT, Float, TIME, Time) \
159 SUBTYPE(FLOAT, Float, DISTANCE, Distance)
160
161 #define NODE_DEFINE_SUBTYPES_VECTOR \
162 SUBTYPE(VECTOR, Vector, NONE, None) \
163 SUBTYPE(VECTOR, Vector, TRANSLATION, Translation) \
164 SUBTYPE(VECTOR, Vector, DIRECTION, Direction) \
165 SUBTYPE(VECTOR, Vector, VELOCITY, Velocity) \
166 SUBTYPE(VECTOR, Vector, ACCELERATION, Acceleration) \
167 SUBTYPE(VECTOR, Vector, EULER, Euler) \
168 SUBTYPE(VECTOR, Vector, XYZ, XYZ)
169
170 #define NODE_DEFINE_SUBTYPES \
171 NODE_DEFINE_SUBTYPES_INT \
172 NODE_DEFINE_SUBTYPES_FLOAT \
173 NODE_DEFINE_SUBTYPES_VECTOR
174
175 #ifdef RNA_RUNTIME
176
177 #include "BLI_linklist.h"
178
179 #include "ED_node.h"
180
181 #include "RE_pipeline.h"
182
183 #include "DNA_scene_types.h"
184 #include "WM_api.h"
185
186 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
187 {
188         bNode *node = (bNode*)ptr->data;
189
190         switch (node->type) {
191                 
192                 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
193                         case ID: return &RNA_##Category##StructName;
194                                 
195                 #include "rna_nodetree_types.h"
196                 
197                 case NODE_GROUP:
198                         return &RNA_NodeGroup;
199                 case NODE_FORLOOP:
200                         return &RNA_NodeForLoop;
201                 case NODE_WHILELOOP:
202                         return &RNA_NodeWhileLoop;
203                         
204                 default:
205                         return &RNA_Node;
206         }
207 }
208
209 static StructRNA *rna_NodeTree_refine(struct PointerRNA *ptr)
210 {
211         bNodeTree *ntree = (bNodeTree*)ptr->data;
212
213         switch (ntree->type) {
214                 case NTREE_SHADER:
215                         return &RNA_ShaderNodeTree;
216                 case NTREE_COMPOSIT:
217                         return &RNA_CompositorNodeTree;
218                 case NTREE_TEXTURE:
219                         return &RNA_TextureNodeTree;
220                 default:
221                         return &RNA_NodeTree;
222         }
223 }
224
225 static char *rna_Node_path(PointerRNA *ptr)
226 {
227         bNode *node = (bNode*)ptr->data;
228
229         return BLI_sprintfN("nodes[\"%s\"]", node->name);
230 }
231
232 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
233 {
234         bNodeSocket *sock = (bNodeSocket*)ptr->data;
235         
236         if (sock->default_value) {
237                 /* This returns the refined socket type with the full definition
238                  * of the default input value with type and subtype.
239                  */
240                 
241                 #define SUBTYPE(socktype, stypename, id, idname) \
242                 { \
243                         bNodeSocketValue##stypename *value = (bNodeSocketValue##stypename*)sock->default_value; \
244                         if (value->subtype == PROP_##id) \
245                                 return &RNA_NodeSocket##stypename##idname; \
246                 }
247                 
248                 switch (sock->type) {
249                 case SOCK_FLOAT:
250                         NODE_DEFINE_SUBTYPES_FLOAT
251                                         break;
252                 case SOCK_INT:
253                         NODE_DEFINE_SUBTYPES_INT
254                                         break;
255                 case SOCK_BOOLEAN:
256                         return &RNA_NodeSocketBoolean;
257                 case SOCK_VECTOR:
258                         NODE_DEFINE_SUBTYPES_VECTOR
259                                         break;
260                 case SOCK_RGBA:
261                         return &RNA_NodeSocketRGBA;
262                 case SOCK_SHADER:
263                         return &RNA_NodeSocketShader;
264                 }
265                 
266                 #undef SUBTYPE
267         }
268         
269         return &RNA_NodeSocket;
270 }
271
272 static char *rna_NodeSocket_path(PointerRNA *ptr)
273 {
274         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
275         bNodeSocket *sock = (bNodeSocket*)ptr->data;
276         bNode *node;
277         int socketindex;
278         
279         /* group sockets */
280         socketindex = BLI_findindex(&ntree->inputs, sock);
281         if (socketindex != -1)
282                 return BLI_sprintfN("inputs[%d]", socketindex);
283         
284         socketindex = BLI_findindex(&ntree->outputs, sock);
285         if (socketindex != -1)
286                 return BLI_sprintfN("outputs[%d]", socketindex);
287         
288         /* node sockets */
289         if (!nodeFindNode(ntree, sock, &node, NULL, NULL)) return NULL;
290         
291         socketindex = BLI_findindex(&node->inputs, sock);
292         if (socketindex != -1)
293                 return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", node->name, socketindex);
294         
295         socketindex = BLI_findindex(&node->outputs, sock);
296         if (socketindex != -1)
297                 return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", node->name, socketindex);
298         
299         return NULL;
300 }
301
302 /* Button Set Funcs for Matte Nodes */
303 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
304 {
305         bNode *node = (bNode*)ptr->data;
306         NodeChroma *chroma = node->storage;
307         
308         chroma->t1 = value;
309         
310         if (value < chroma->t2)
311                 chroma->t2 = value;
312 }
313
314 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
315 {
316         bNode *node = (bNode*)ptr->data;
317         NodeChroma *chroma = node->storage;
318         
319         if (value > chroma->t1)
320                 value = chroma->t1;
321         
322         chroma->t2 = value;
323 }
324
325 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
326 {
327         bNode *node = (bNode*)ptr->data;
328         NodeChroma *chroma = node->storage;
329
330         chroma->t1 = value;
331 }
332
333 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
334 {
335         bNode *node = (bNode*)ptr->data;
336         NodeChroma *chroma = node->storage;
337
338         chroma->t2 = value;
339 }
340
341 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
342 {
343         bNode *node = (bNode*)ptr->data;
344         NodeChroma *chroma = node->storage;
345
346         chroma->t1 = value;
347 }
348
349 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
350 {
351         bNode *node = (bNode*)ptr->data;
352         NodeChroma *chroma = node->storage;
353
354         chroma->t2 = value;
355 }
356
357
358 static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value)
359 {
360         bNode *node = (bNode*)ptr->data;
361
362         if (node->id) {
363                 id_us_min(node->id);
364                 node->id = NULL;
365         }
366
367         node->id = value.data;
368
369         id_us_plus(node->id);
370 }
371
372
373
374 static void node_update(Main *bmain, Scene *UNUSED(scene), bNodeTree *ntree, bNode *node)
375 {
376         ED_node_generic_update(bmain, ntree, node);
377 }
378
379 static void rna_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
380 {
381         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
382         bNode *node = (bNode*)ptr->data;
383
384         node_update(bmain, scene, ntree, node);
385 }
386
387 static void rna_Node_tex_image_update(Main *bmain, Scene *scene, PointerRNA *ptr)
388 {
389         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
390         bNode *node = (bNode*)ptr->data;
391
392         node_update(bmain, scene, ntree, node);
393         WM_main_add_notifier(NC_IMAGE, NULL);
394 }
395
396 static void rna_Node_material_update(Main *bmain, Scene *scene, PointerRNA *ptr)
397 {
398         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
399         bNode *node = (bNode*)ptr->data;
400
401         if (node->id)
402                 nodeSetActive(ntree, node);
403
404         node_update(bmain, scene, ntree, node);
405 }
406
407 static void rna_NodeGroup_update(Main *bmain, Scene *scene, PointerRNA *ptr)
408 {
409         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
410         bNode *node = (bNode*)ptr->data;
411         
412         ntreeUpdateTree((bNodeTree *)node->id);
413         
414         node_update(bmain, scene, ntree, node);
415 }
416
417 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
418 {
419         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
420         bNode *node = (bNode*)ptr->data;
421         char oldname[sizeof(node->name)];
422         
423         /* make a copy of the old name first */
424         BLI_strncpy(oldname, node->name, sizeof(node->name));
425         /* set new name */
426         BLI_strncpy_utf8(node->name, value, sizeof(node->name));
427         
428         nodeUniqueName(ntree, node);
429         
430         /* fix all the animation data which may link to this */
431         BKE_all_animdata_fix_paths_rename(NULL, "nodes", oldname, node->name);
432 }
433
434 static void rna_NodeSocket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
435 {
436         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
437         bNodeSocket *sock = (bNodeSocket*)ptr->data;
438         bNode *node;
439         
440         if (nodeFindNode(ntree, sock, &node, NULL, NULL))
441                 node_update(bmain, scene, ntree, node);
442 }
443
444 static void rna_NodeGroupSocket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
445 {
446         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
447         bNodeSocket *sock = (bNodeSocket*)ptr->data;
448         bNode *node;
449         
450         ntreeUpdateTree(ntree);
451         
452         if (nodeFindNode(ntree, sock, &node, NULL, NULL))
453                 node_update(bmain, scene, ntree, node);
454 }
455
456 #if 0 /* UNUSED */
457 static void rna_NodeLink_update(Main *bmain, Scene *scene, PointerRNA *ptr)
458 {
459         bNodeTree *ntree = (bNodeTree*)ptr->id.data;
460
461         ntree->update |= NTREE_UPDATE_LINKS;
462         ntreeUpdateTree(ntree);
463 }
464 #endif
465
466 static void rna_NodeSocketInt_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
467 {
468         bNodeSocket *sock = (bNodeSocket*)ptr->data;
469         bNodeSocketValueInt *val = (bNodeSocketValueInt*)sock->default_value;
470         *softmin = val->min;
471         *softmax = val->max;
472 }
473
474 static void rna_NodeSocketFloat_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
475 {
476         bNodeSocket *sock = (bNodeSocket*)ptr->data;
477         bNodeSocketValueFloat *val = (bNodeSocketValueFloat*)sock->default_value;
478         *softmin = val->min;
479         *softmax = val->max;
480 }
481
482 static void rna_NodeSocketVector_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
483 {
484         bNodeSocket *sock = (bNodeSocket*)ptr->data;
485         bNodeSocketValueVector *val = (bNodeSocketValueVector*)sock->default_value;
486         *softmin = val->min;
487         *softmax = val->max;
488 }
489
490 static EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
491 {
492         EnumPropertyItem *item = NULL;
493         EnumPropertyItem tmp = {0, "", 0, "", ""};
494         int i = 0, totitem = 0;
495         
496         while (rl) {
497                 tmp.identifier = rl->name;
498                 tmp.name = rl->name;
499                 tmp.value = i++;
500                 RNA_enum_item_add(&item, &totitem, &tmp);
501                 rl = rl->next;
502         }
503         
504         RNA_enum_item_end(&item, &totitem);
505
506         return item;
507 }
508
509 static EnumPropertyItem *rna_Node_scene_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
510                                                     PropertyRNA *UNUSED(prop), int *free)
511 {
512         bNode *node = (bNode*)ptr->data;
513         Scene *sce = (Scene *)node->id;
514         EnumPropertyItem *item = NULL;
515         RenderLayer *rl;
516         
517         if (!sce) return NULL;
518         
519         rl = sce->r.layers.first;
520         item = renderresult_layers_add_enum(rl);
521         
522         *free = 1;
523         
524         return item;
525 }
526
527 static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA *ptr,
528                                                 PropertyRNA *UNUSED(prop), int *free)
529 {
530         bNode *node = (bNode*)ptr->data;
531         EnumPropertyItem *item = NULL;
532         EnumPropertyItem tmp = {0, "", 0, "", ""};
533         int totitem = 0;
534         
535         switch (node->custom1) {
536                 case CMP_NODE_CHANNEL_MATTE_CS_RGB:
537                         tmp.identifier = "R"; tmp.name = "R"; tmp.value = 1;
538                         RNA_enum_item_add(&item, &totitem, &tmp);
539                         tmp.identifier = "G"; tmp.name = "G"; tmp.value = 2;
540                         RNA_enum_item_add(&item, &totitem, &tmp);
541                         tmp.identifier = "B"; tmp.name = "B"; tmp.value = 3;
542                         RNA_enum_item_add(&item, &totitem, &tmp);
543                         break;
544                 case CMP_NODE_CHANNEL_MATTE_CS_HSV:
545                         tmp.identifier = "H"; tmp.name = "H"; tmp.value = 1;
546                         RNA_enum_item_add(&item, &totitem, &tmp);
547                         tmp.identifier = "S"; tmp.name = "S"; tmp.value = 2;
548                         RNA_enum_item_add(&item, &totitem, &tmp);
549                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
550                         RNA_enum_item_add(&item, &totitem, &tmp);
551                         break;
552                 case CMP_NODE_CHANNEL_MATTE_CS_YUV:
553                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
554                         RNA_enum_item_add(&item, &totitem, &tmp);
555                         tmp.identifier = "G"; tmp.name = "U"; tmp.value = 2;
556                         RNA_enum_item_add(&item, &totitem, &tmp);
557                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
558                         RNA_enum_item_add(&item, &totitem, &tmp);
559                         break;
560                 case CMP_NODE_CHANNEL_MATTE_CS_YCC:
561                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
562                         RNA_enum_item_add(&item, &totitem, &tmp);
563                         tmp.identifier = "CB"; tmp.name = "Cr"; tmp.value = 2;
564                         RNA_enum_item_add(&item, &totitem, &tmp);
565                         tmp.identifier = "CR"; tmp.name = "Cb"; tmp.value = 3;
566                         RNA_enum_item_add(&item, &totitem, &tmp);
567                         break;
568                 default:
569                         break;
570         }
571
572         RNA_enum_item_end(&item, &totitem);
573         *free = 1;
574         
575         return item;
576 }
577
578 static bNode *rna_NodeTree_node_new(bNodeTree *ntree, bContext *C, ReportList *reports,
579                                     int type, bNodeTree *group)
580 {
581         bNode *node;
582         bNodeTemplate ntemp;
583
584         if (type == NODE_GROUP && group == NULL) {
585                 BKE_reportf(reports, RPT_ERROR, "node type \'GROUP\' missing group argument");
586                 return NULL;
587         }
588         
589         ntemp.type = type;
590         ntemp.ngroup = group;
591         ntemp.scene = CTX_data_scene(C);
592         ntemp.main = CTX_data_main(C);
593         node = nodeAddNode(ntree, &ntemp);
594         
595         if (node == NULL) {
596                 BKE_reportf(reports, RPT_ERROR, "Unable to create node");
597         }
598         else {
599                 ntreeUpdateTree(ntree); /* update group node socket links*/
600                 nodeUpdate(ntree, node);
601                 WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
602
603                 if (group)
604                         id_us_plus(&group->id);
605         }
606
607         return node;
608 }
609
610 static bNode *rna_NodeTree_node_composite_new(bNodeTree *ntree, bContext *C, ReportList *reports,
611                                               int type, bNodeTree *group)
612 {
613         /* raises error on failure */
614         bNode *node = rna_NodeTree_node_new(ntree, C, reports, type, group);
615         
616         if (node) {
617                 if (ELEM4(node->type, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE, CMP_NODE_R_LAYERS)) {
618                         /* annoying, find the node tree we are in, scene can be NULL */
619                         Scene *scene;
620                         for (scene = CTX_data_main(C)->scene.first; scene; scene = scene->id.next) {
621                                 if (scene->nodetree == ntree) {
622                                         break;
623                                 }
624                         }
625                         node->id = (ID *)scene;
626                         id_us_plus(node->id);
627                 }
628
629                 ntreeCompositForceHidden(ntree, CTX_data_scene(C));
630                 ntreeUpdateTree(ntree);
631         }
632
633         return node;
634 }
635
636 static bNode *rna_NodeTree_node_texture_new(bNodeTree *ntree, bContext *C, ReportList *reports,
637                                             int type, bNodeTree *group)
638 {
639         /* raises error on failure */
640         bNode *node = rna_NodeTree_node_new(ntree, C, reports, type, group);
641
642         if (node) {
643                 ntreeTexCheckCyclics(ntree);
644         }
645
646         return node;
647 }
648
649 static void rna_NodeTree_node_remove(bNodeTree *ntree, ReportList *reports, bNode *node)
650 {
651         if (BLI_findindex(&ntree->nodes, node) == -1) {
652                 BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in nodetree", node->name);
653         }
654         else {
655                 if (node->id)
656                         id_us_min(node->id);
657
658                 nodeFreeNode(ntree, node);
659                 ntreeUpdateTree(ntree); /* update group node socket links*/
660
661                 WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
662         }
663 }
664
665 static void rna_NodeTree_node_clear(bNodeTree *ntree)
666 {
667         bNode *node = ntree->nodes.first;
668
669         while (node) {
670                 bNode *next_node = node->next;
671
672                 if (node->id)
673                         id_us_min(node->id);
674
675                 nodeFreeNode(ntree, node);
676
677                 node = next_node;
678         }
679
680         ntreeUpdateTree(ntree); /* update group node socket links*/
681
682         WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
683 }
684
685 static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, ReportList *reports,
686                                         bNodeSocket *fromsock, bNodeSocket *tosock)
687 {
688         bNodeLink *ret;
689         bNode *fromnode = NULL, *tonode = NULL;
690         int from_in_out, to_in_out;
691
692         nodeFindNode(ntree, fromsock, &fromnode, NULL, &from_in_out);
693         nodeFindNode(ntree, tosock, &tonode, NULL, &to_in_out);
694         
695         if (&from_in_out == &to_in_out) {
696                 BKE_reportf(reports, RPT_ERROR, "Same input/output direction of sockets");
697                 return NULL;
698         }
699
700         /* unlink node input socket */
701         if (to_in_out == SOCK_IN)
702                 nodeRemSocketLinks(ntree, tosock);
703         else
704                 nodeRemSocketLinks(ntree, fromsock);
705
706         ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock);
707         
708         if (ret) {
709                 if (tonode)
710                         nodeUpdate(ntree, tonode);
711
712                 ntreeUpdateTree(ntree);
713
714                 WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
715         }
716
717         return ret;
718 }
719
720 static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, bNodeLink *link)
721 {
722         if (BLI_findindex(&ntree->links, link) == -1) {
723                 BKE_reportf(reports, RPT_ERROR, "Unable to locate link in nodetree");
724         }
725         else {
726                 nodeRemLink(ntree, link);
727                 ntreeUpdateTree(ntree);
728
729                 WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
730         }
731 }
732
733 static void rna_NodeTree_link_clear(bNodeTree *ntree)
734 {
735         bNodeLink *link = ntree->links.first;
736
737         while (link) {
738                 bNodeLink *next_link = link->next;
739
740                 nodeRemLink(ntree, link);
741
742                 link = next_link;
743         }
744         ntreeUpdateTree(ntree);
745
746         WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
747 }
748
749 static bNodeSocket *rna_NodeTree_input_new(bNodeTree *ntree, ReportList *UNUSED(reports), const char *name, int type)
750 {
751         /* XXX should check if tree is a group here! no good way to do this currently. */
752         bNodeSocket *gsock = node_group_add_socket(ntree, name, type, SOCK_IN);
753         
754         ntree->update |= NTREE_UPDATE_GROUP_IN;
755         ntreeUpdateTree(ntree);
756         WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
757         return gsock;
758 }
759
760 static bNodeSocket *rna_NodeTree_output_new(bNodeTree *ntree, ReportList *UNUSED(reports), const char *name, int type)
761 {
762         /* XXX should check if tree is a group here! no good way to do this currently. */
763         bNodeSocket *gsock = node_group_add_socket(ntree, name, type, SOCK_OUT);
764         
765         ntree->update |= NTREE_UPDATE_GROUP_OUT;
766         ntreeUpdateTree(ntree);
767         WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
768         return gsock;
769 }
770
771 static bNodeSocket *rna_NodeTree_input_expose(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock, int add_link)
772 {
773         bNode *node;
774         bNodeSocket *gsock;
775         int index, in_out;
776         
777         if (!nodeFindNode(ntree, sock, &node, &index, &in_out))
778                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket in nodetree");
779         else if (in_out != SOCK_IN)
780                 BKE_reportf(reports, RPT_ERROR, "Socket is not an input");
781         else {
782                 /* XXX should check if tree is a group here! no good way to do this currently. */
783                 gsock = node_group_add_socket(ntree, sock->name, sock->type, SOCK_IN);
784                 if (add_link)
785                         nodeAddLink(ntree, NULL, gsock, node, sock);
786                 
787                 ntree->update |= NTREE_UPDATE_GROUP_IN;
788                 ntreeUpdateTree(ntree);
789                 WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
790                 return gsock;
791         }
792         return NULL;
793 }
794
795 static bNodeSocket *rna_NodeTree_output_expose(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock, int add_link)
796 {
797         bNode *node;
798         bNodeSocket *gsock;
799         int index, in_out;
800         
801         if (!nodeFindNode(ntree, sock, &node, &index, &in_out))
802                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket in nodetree");
803         else if (in_out != SOCK_OUT)
804                 BKE_reportf(reports, RPT_ERROR, "Socket is not an output");
805         else {
806                 /* XXX should check if tree is a group here! no good way to do this currently. */
807                 gsock = node_group_add_socket(ntree, sock->name, sock->type, SOCK_OUT);
808                 if (add_link)
809                         nodeAddLink(ntree, node, sock, NULL, gsock);
810                 
811                 ntree->update |= NTREE_UPDATE_GROUP_OUT;
812                 ntreeUpdateTree(ntree);
813                 WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
814                 return gsock;
815         }
816         return NULL;
817 }
818
819 static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
820 {
821         bNode *node = ptr->data;
822         init_tex_mapping(node->storage);
823         rna_Node_update(bmain, scene, ptr);
824 }
825
826 static void rna_NodeOutputFile_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
827 {
828         bNode *node = ptr->data;
829         rna_iterator_listbase_begin(iter, &node->inputs, NULL);
830 }
831
832 static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *iter)
833 {
834         PointerRNA ptr;
835         bNodeSocket *sock = rna_iterator_listbase_get(iter);
836         RNA_pointer_create(iter->ptr.id.data, &RNA_NodeOutputFileSlotFile, sock->storage, &ptr);
837         return ptr;
838 }
839
840 static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter)
841 {
842         PointerRNA ptr;
843         bNodeSocket *sock = rna_iterator_listbase_get(iter);
844         RNA_pointer_create(iter->ptr.id.data, &RNA_NodeOutputFileSlotLayer, sock->storage, &ptr);
845         return ptr;
846 }
847
848 static int rna_NodeOutputFileSocket_find_node(bNodeTree *ntree, NodeImageMultiFileSocket *data, bNode **nodep, bNodeSocket **sockp)
849 {
850         bNode *node;
851         bNodeSocket *sock;
852         
853         for (node= ntree->nodes.first; node; node= node->next) {
854                 for (sock= node->inputs.first; sock; sock= sock->next) {
855                         NodeImageMultiFileSocket *sockdata = sock->storage;
856                         if (sockdata==data) {
857                                 *nodep = node;
858                                 *sockp = sock;
859                                 return 1;
860                         }
861                 }
862         }
863         
864         *nodep= NULL;
865         *sockp= NULL;
866         return 0;
867 }
868
869 static void rna_NodeOutputFileSlotFile_path_set(PointerRNA *ptr, const char *value)
870 {
871         bNodeTree *ntree = ptr->id.data;
872         NodeImageMultiFileSocket *sockdata = ptr->data;
873         bNode *node;
874         bNodeSocket *sock;
875         
876         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
877                 ntreeCompositOutputFileSetPath(node, sock, value);
878         }
879 }
880
881 static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *value)
882 {
883         bNodeTree *ntree = ptr->id.data;
884         NodeImageMultiFileSocket *sockdata = ptr->data;
885         bNode *node;
886         bNodeSocket *sock;
887         
888         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
889                 ntreeCompositOutputFileSetLayer(node, sock, value);
890         }
891 }
892
893 #else
894
895 static EnumPropertyItem prop_scene_layer_items[] = {
896 { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
897 {0, NULL, 0, NULL, NULL}};
898
899 static EnumPropertyItem prop_tri_channel_items[] = {
900 { 1, "R", 0, "R", ""},
901 { 2, "G", 0, "G", ""},
902 { 3, "B", 0, "B", ""},
903 {0, NULL, 0, NULL, NULL}};
904
905 static EnumPropertyItem node_flip_items[] = {
906 {0, "X",  0, "Flip X",     ""},
907 {1, "Y",  0, "Flip Y",     ""},
908 {2, "XY", 0, "Flip X & Y", ""},
909 {0, NULL, 0, NULL, NULL}};
910
911 static EnumPropertyItem node_ycc_items[] = {
912 { 0, "ITUBT601", 0, "ITU 601",  ""},
913 { 1, "ITUBT709", 0, "ITU 709",  ""},
914 { 2, "JFIF",     0, "Jpeg",     ""},
915 {0, NULL, 0, NULL, NULL}};
916
917 static EnumPropertyItem node_glossy_items[] = {
918 {SHD_GLOSSY_SHARP,    "SHARP",    0, "Sharp",    ""},
919 {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
920 {SHD_GLOSSY_GGX,      "GGX",      0, "GGX",      ""},
921 {0, NULL, 0, NULL, NULL}};
922
923 #define MaxNodes 50000
924
925 enum
926 {
927         Category_GroupNode,
928         Category_LoopNode,
929         Category_LayoutNode,
930         Category_ShaderNode,
931         Category_CompositorNode,
932         Category_TextureNode,
933 };
934
935 typedef struct NodeInfo
936 {
937         int defined;
938         int category;
939         const char *enum_name;
940         const char *struct_name;
941         const char *base_name;
942         int icon;
943         const char *ui_name;
944         const char *ui_desc;
945 } NodeInfo;
946
947 static NodeInfo nodes[MaxNodes];
948
949 static void reg_node(int ID, int category, const char *enum_name, const char *struct_name,
950                                          const char *base_name, const char *ui_name, const char *ui_desc)
951 {
952         NodeInfo *ni = nodes + ID;
953         
954         ni->defined = 1;
955         ni->category = category;
956         ni->enum_name = enum_name;
957         ni->struct_name = struct_name;
958         ni->base_name = base_name;
959         ni->ui_name = ui_name;
960         ni->ui_desc = ui_desc;
961 }
962
963 static void init(void)
964 {
965         memset(nodes, 0, sizeof nodes);
966         
967         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
968                 reg_node(ID, Category_##Category, EnumName, STRINGIFY_ARG(Category##StructName), #Category, UIName, UIDesc);
969                 
970         #include "rna_nodetree_types.h"
971         
972         reg_node(NODE_GROUP, Category_GroupNode, "GROUP", "NodeGroup", "Node", "Group", "");
973         reg_node(NODE_FORLOOP, Category_LoopNode, "FORLOOP", "NodeForLoop", "Node", "ForLoop", "");
974         reg_node(NODE_WHILELOOP, Category_LoopNode, "WHILELOOP", "NodeWhileLoop", "Node", "WhileLoop", "");
975         reg_node(NODE_FRAME, Category_LayoutNode, "FRAME", "NodeFrame", "Node", "Frame", "");
976 }
977
978 static StructRNA* def_node(BlenderRNA *brna, int node_id)
979 {
980         StructRNA *srna;
981         NodeInfo *node = nodes + node_id;
982         
983         srna = RNA_def_struct(brna, node->struct_name, node->base_name);
984         RNA_def_struct_ui_text(srna, node->ui_name, node->ui_desc);
985         RNA_def_struct_sdna(srna, "bNode");
986         
987         return srna;
988 }
989
990 static void alloc_node_type_items(EnumPropertyItem *items, int category)
991 {
992         int i;
993         int count = 3;
994         EnumPropertyItem *item  = items;
995         
996         for (i = 0; i<MaxNodes; i++)
997                 if (nodes[i].defined && nodes[i].category == category)
998                         count++;
999                 
1000         /*item = items = MEM_callocN(count * sizeof(EnumPropertyItem), "alloc_node_type_items");*/
1001         
1002         for (i = 0; i<MaxNodes; i++) {
1003                 NodeInfo *node = nodes + i;
1004                 if (node->defined && node->category == category) {
1005                         item->value = i;
1006                         item->identifier = node->enum_name;
1007                         item->icon = node->icon;
1008                         item->name = node->ui_name;
1009                         item->description = node->ui_desc;
1010                 
1011                         item++;
1012                 }
1013         }
1014         
1015         item->value = NODE_DYNAMIC;
1016         item->identifier = "SCRIPT";
1017         item->icon = 0;
1018         item->name = "Script";
1019         item->description = "";
1020         
1021         item++;
1022         
1023         item->value = NODE_GROUP;
1024         item->identifier = "GROUP";
1025         item->icon = 0;
1026         item->name = "Group";
1027         item->description = "";
1028         
1029         item++;
1030         
1031         /* NOTE!, increase 'count' when adding items here */
1032         
1033         memset(item, 0, sizeof(EnumPropertyItem));
1034 }
1035
1036
1037 /* -- Common nodes ---------------------------------------------------------- */
1038
1039 static void def_group(StructRNA *srna)
1040 {
1041         PropertyRNA *prop;
1042         
1043         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
1044         RNA_def_property_pointer_sdna(prop, NULL, "id");
1045         RNA_def_property_struct_type(prop, "NodeTree");
1046         RNA_def_property_flag(prop, PROP_EDITABLE);
1047         RNA_def_property_ui_text(prop, "Node Tree", "");
1048         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroup_update");
1049 }
1050
1051 static void def_forloop(StructRNA *srna)
1052 {
1053         PropertyRNA *prop;
1054         
1055         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
1056         RNA_def_property_pointer_sdna(prop, NULL, "id");
1057         RNA_def_property_struct_type(prop, "NodeTree");
1058         RNA_def_property_flag(prop, PROP_EDITABLE);
1059         RNA_def_property_ui_text(prop, "Node Tree", "");
1060         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroup_update");
1061 }
1062
1063 static void def_whileloop(StructRNA *srna)
1064 {
1065         PropertyRNA *prop;
1066         
1067         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
1068         RNA_def_property_pointer_sdna(prop, NULL, "id");
1069         RNA_def_property_struct_type(prop, "NodeTree");
1070         RNA_def_property_flag(prop, PROP_EDITABLE);
1071         RNA_def_property_ui_text(prop, "Node Tree", "");
1072         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroup_update");
1073
1074         prop = RNA_def_property(srna, "max_iterations", PROP_INT, PROP_NONE);
1075         RNA_def_property_int_sdna(prop, NULL, "custom1");
1076         RNA_def_property_range(prop, 0.0f, SHRT_MAX);
1077         RNA_def_property_ui_text(prop, "Max. Iterations", "Limit for number of iterations");
1078         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroup_update");
1079 }
1080
1081 static void def_frame(StructRNA *srna)
1082 {
1083 /*      PropertyRNA *prop; */
1084         
1085 }
1086
1087 static void def_math(StructRNA *srna)
1088 {
1089         PropertyRNA *prop;
1090         
1091         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
1092         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1093         RNA_def_property_enum_items(prop, node_math_items);
1094         RNA_def_property_ui_text(prop, "Operation", "");
1095         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1096 }
1097
1098 static void def_vector_math(StructRNA *srna)
1099 {
1100         PropertyRNA *prop;
1101         
1102         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
1103         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1104         RNA_def_property_enum_items(prop, node_vec_math_items);
1105         RNA_def_property_ui_text(prop, "Operation", "");
1106         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1107 }
1108
1109 static void def_rgb_curve(StructRNA *srna)
1110 {
1111         PropertyRNA *prop;
1112         
1113         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
1114         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1115         RNA_def_property_struct_type(prop, "CurveMapping");
1116         RNA_def_property_ui_text(prop, "Mapping", "");
1117         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1118 }
1119
1120 static void def_vector_curve(StructRNA *srna)
1121 {
1122         PropertyRNA *prop;
1123         
1124         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
1125         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1126         RNA_def_property_struct_type(prop, "CurveMapping");
1127         RNA_def_property_ui_text(prop, "Mapping", "");
1128         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1129 }
1130
1131 static void def_time(StructRNA *srna)
1132 {
1133         PropertyRNA *prop;
1134         
1135         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
1136         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1137         RNA_def_property_struct_type(prop, "CurveMapping");
1138         RNA_def_property_ui_text(prop, "Curve", "");
1139         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1140         
1141         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
1142         RNA_def_property_int_sdna(prop, NULL, "custom1");
1143         RNA_def_property_ui_text(prop, "Start Frame", "");
1144         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1145         
1146         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
1147         RNA_def_property_int_sdna(prop, NULL, "custom2");
1148         RNA_def_property_ui_text(prop, "End Frame", "");
1149         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1150 }
1151
1152 static void def_colorramp(StructRNA *srna)
1153 {
1154         PropertyRNA *prop;
1155         
1156         prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NONE);
1157         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1158         RNA_def_property_struct_type(prop, "ColorRamp");
1159         RNA_def_property_ui_text(prop, "Color Ramp", "");
1160         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1161 }
1162
1163 static void def_mix_rgb(StructRNA *srna)
1164 {
1165         PropertyRNA *prop;
1166         
1167         prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
1168         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1169         RNA_def_property_enum_items(prop, ramp_blend_items);
1170         RNA_def_property_ui_text(prop, "Blend Type", "");
1171         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1172         
1173         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
1174         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
1175         RNA_def_property_ui_text(prop, "Alpha", "Include alpha of second input in this operation");
1176         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1177 }
1178
1179 static void def_texture(StructRNA *srna)
1180 {
1181         PropertyRNA *prop;
1182         
1183         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
1184         RNA_def_property_pointer_sdna(prop, NULL, "id");
1185         RNA_def_property_struct_type(prop, "Texture");
1186         RNA_def_property_flag(prop, PROP_EDITABLE);
1187         RNA_def_property_ui_text(prop, "Texture", "");
1188         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1189         
1190         prop = RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
1191         RNA_def_property_int_sdna(prop, NULL, "custom1");
1192         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
1193         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1194 }
1195
1196
1197 /* -- Shader Nodes ---------------------------------------------------------- */
1198
1199 static void def_sh_material(StructRNA *srna)
1200 {
1201         PropertyRNA *prop;
1202
1203         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
1204         RNA_def_property_pointer_sdna(prop, NULL, "id");
1205         RNA_def_property_struct_type(prop, "Material");
1206         RNA_def_property_flag(prop, PROP_EDITABLE);
1207         RNA_def_property_ui_text(prop, "Material", "");
1208         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_material_update");
1209
1210         prop = RNA_def_property(srna, "use_diffuse", PROP_BOOLEAN, PROP_NONE);
1211         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
1212         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
1213         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1214
1215         prop = RNA_def_property(srna, "use_specular", PROP_BOOLEAN, PROP_NONE);
1216         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
1217         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
1218         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1219         
1220         prop = RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
1221         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
1222         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
1223         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1224 }
1225
1226 static void def_sh_mapping(StructRNA *srna)
1227 {
1228         PropertyRNA *prop;
1229         
1230         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
1231
1232         prop = RNA_def_property(srna, "translation", PROP_FLOAT, PROP_TRANSLATION);
1233         RNA_def_property_float_sdna(prop, NULL, "loc");
1234         RNA_def_property_ui_text(prop, "Location", "");
1235         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1236         
1237                 /* Not PROP_XYZ, this is now in radians, no more degrees */
1238         prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
1239         RNA_def_property_float_sdna(prop, NULL, "rot");
1240         RNA_def_property_ui_text(prop, "Rotation", "");
1241         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1242         
1243         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
1244         RNA_def_property_float_sdna(prop, NULL, "size");
1245         RNA_def_property_ui_text(prop, "Scale", "");
1246         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1247         
1248         prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_XYZ);
1249         RNA_def_property_float_sdna(prop, NULL, "min");
1250         RNA_def_property_ui_text(prop, "Minimum", "Minimum value for clipping");
1251         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1252         
1253         prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_XYZ);
1254         RNA_def_property_float_sdna(prop, NULL, "max");
1255         RNA_def_property_ui_text(prop, "Maximum", "Maximum value for clipping");
1256         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1257         
1258         prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
1259         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
1260         RNA_def_property_ui_text(prop, "Has Minimum", "Whether to use minimum clipping value");
1261         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1262         
1263         prop = RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
1264         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
1265         RNA_def_property_ui_text(prop, "Has Maximum", "Whether to use maximum clipping value");
1266         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1267 }
1268
1269 static void def_sh_geometry(StructRNA *srna)
1270 {
1271         PropertyRNA *prop;
1272         
1273         RNA_def_struct_sdna_from(srna, "NodeGeometry", "storage");
1274         
1275         prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
1276         RNA_def_property_string_sdna(prop, NULL, "uvname");
1277         RNA_def_property_ui_text(prop, "UV Map", "");
1278         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1279         
1280         prop = RNA_def_property(srna, "color_layer", PROP_STRING, PROP_NONE);
1281         RNA_def_property_string_sdna(prop, NULL, "colname");
1282         RNA_def_property_ui_text(prop, "Vertex Color Layer", "");
1283         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1284 }
1285
1286 static void def_sh_attribute(StructRNA *srna)
1287 {
1288         PropertyRNA *prop;
1289         
1290         RNA_def_struct_sdna_from(srna, "NodeShaderAttribute", "storage");
1291         
1292         prop = RNA_def_property(srna, "attribute_name", PROP_STRING, PROP_NONE);
1293         RNA_def_property_string_sdna(prop, NULL, "name");
1294         RNA_def_property_ui_text(prop, "Attribute Name", "");
1295         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1296 }
1297
1298 static void def_sh_tex(StructRNA *srna)
1299 {
1300         PropertyRNA *prop;
1301
1302         prop = RNA_def_property(srna, "texture_mapping", PROP_POINTER, PROP_NONE);
1303         RNA_def_property_pointer_sdna(prop, NULL, "base.tex_mapping");
1304         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1305         RNA_def_property_ui_text(prop, "Texture Mapping", "Texture coordinate mapping settings");
1306
1307         prop = RNA_def_property(srna, "color_mapping", PROP_POINTER, PROP_NONE);
1308         RNA_def_property_pointer_sdna(prop, NULL, "base.color_mapping");
1309         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1310         RNA_def_property_ui_text(prop, "Color Mapping", "Color mapping settings");
1311 }
1312
1313 static void def_sh_tex_sky(StructRNA *srna)
1314 {
1315         PropertyRNA *prop;
1316         
1317         RNA_def_struct_sdna_from(srna, "NodeTexSky", "storage");
1318         def_sh_tex(srna);
1319         
1320         prop = RNA_def_property(srna, "sun_direction", PROP_FLOAT, PROP_DIRECTION);
1321         RNA_def_property_ui_text(prop, "Sun Direction", "Direction from where the sun is shining");
1322         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1323         
1324         prop = RNA_def_property(srna, "turbidity", PROP_FLOAT, PROP_NONE);
1325         RNA_def_property_ui_text(prop, "Turbidity", "");
1326         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1327 }
1328
1329 static void def_sh_tex_environment(StructRNA *srna)
1330 {
1331         static const EnumPropertyItem prop_color_space_items[] = {
1332                 {SHD_COLORSPACE_COLOR, "COLOR", 0, "Color",
1333                                        "Image contains color data, and will be converted to linear color for rendering"},
1334                 {SHD_COLORSPACE_NONE, "NONE", 0, "Non-Color Data",
1335                                       "Image contains non-color data, for example a displacement or normal map, "
1336                                       "and will not be converted"},
1337                 {0, NULL, 0, NULL, NULL}};
1338
1339         static const EnumPropertyItem prop_projection_items[] = {
1340                 {SHD_PROJ_EQUIRECTANGULAR, "EQUIRECTANGULAR", 0, "Equirectangular",
1341                                            "Equirectangular or latitude-longitude projection"},
1342                 {SHD_PROJ_MIRROR_BALL, "MIRROR_BALL", 0, "Mirror Ball",
1343                                        "Projection from an orthographic photo of a mirror ball"},
1344                 {0, NULL, 0, NULL, NULL}};
1345         
1346         PropertyRNA *prop;
1347
1348         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1349         RNA_def_property_pointer_sdna(prop, NULL, "id");
1350         RNA_def_property_struct_type(prop, "Image");
1351         RNA_def_property_flag(prop, PROP_EDITABLE);
1352         RNA_def_property_ui_text(prop, "Image", "");
1353         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_tex_image_update");
1354
1355         RNA_def_struct_sdna_from(srna, "NodeTexEnvironment", "storage");
1356         def_sh_tex(srna);
1357
1358         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
1359         RNA_def_property_enum_items(prop, prop_color_space_items);
1360         RNA_def_property_ui_text(prop, "Color Space", "Image file color space");
1361         RNA_def_property_update(prop, 0, "rna_Node_update");
1362
1363         prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
1364         RNA_def_property_enum_items(prop, prop_projection_items);
1365         RNA_def_property_ui_text(prop, "Projection", "Projection of the input image");
1366         RNA_def_property_update(prop, 0, "rna_Node_update");
1367
1368 }
1369
1370 static void def_sh_tex_image(StructRNA *srna)
1371 {
1372         static const EnumPropertyItem prop_color_space_items[] = {
1373                 {SHD_COLORSPACE_COLOR, "COLOR", 0, "Color",
1374                                        "Image contains color data, and will be converted to linear color for rendering"},
1375                 {SHD_COLORSPACE_NONE, "NONE", 0, "Non-Color Data",
1376                                       "Image contains non-color data, for example a displacement or normal map, "
1377                                       "and will not be converted"},
1378                 {0, NULL, 0, NULL, NULL}};
1379
1380         PropertyRNA *prop;
1381
1382         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1383         RNA_def_property_pointer_sdna(prop, NULL, "id");
1384         RNA_def_property_struct_type(prop, "Image");
1385         RNA_def_property_flag(prop, PROP_EDITABLE);
1386         RNA_def_property_ui_text(prop, "Image", "");
1387         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_tex_image_update");
1388
1389         RNA_def_struct_sdna_from(srna, "NodeTexImage", "storage");
1390         def_sh_tex(srna);
1391
1392         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
1393         RNA_def_property_enum_items(prop, prop_color_space_items);
1394         RNA_def_property_ui_text(prop, "Color Space", "Image file color space");
1395         RNA_def_property_update(prop, 0, "rna_Node_update");
1396 }
1397
1398 static void def_sh_tex_gradient(StructRNA *srna)
1399 {
1400         static EnumPropertyItem prop_gradient_type[] = {
1401                 {SHD_BLEND_LINEAR, "LINEAR", 0, "Linear", "Create a linear progression"},
1402                 {SHD_BLEND_QUADRATIC, "QUADRATIC", 0, "Quadratic", "Create a quadratic progression"},
1403                 {SHD_BLEND_EASING, "EASING", 0, "Easing", "Create a progression easing from one step to the next"},
1404                 {SHD_BLEND_DIAGONAL, "DIAGONAL", 0, "Diagonal", "Create a diagonal progression"},
1405                 {SHD_BLEND_SPHERICAL, "SPHERICAL", 0, "Spherical", "Create a spherical progression"},
1406                 {SHD_BLEND_QUADRATIC_SPHERE, "QUADRATIC_SPHERE", 0, "Quadratic sphere",
1407                                              "Create a quadratic progression in the shape of a sphere"},
1408                 {SHD_BLEND_RADIAL, "RADIAL", 0, "Radial", "Create a radial progression"},
1409                 {0, NULL, 0, NULL, NULL}};
1410
1411         PropertyRNA *prop;
1412         
1413         RNA_def_struct_sdna_from(srna, "NodeTexGradient", "storage");
1414         def_sh_tex(srna);
1415
1416         prop = RNA_def_property(srna, "gradient_type", PROP_ENUM, PROP_NONE);
1417         RNA_def_property_enum_items(prop, prop_gradient_type);
1418         RNA_def_property_ui_text(prop, "Gradient Type", "Style of the color blending");
1419         RNA_def_property_update(prop, 0, "rna_Node_update");
1420 }
1421
1422 static void def_sh_tex_noise(StructRNA *srna)
1423 {
1424         RNA_def_struct_sdna_from(srna, "NodeTexNoise", "storage");
1425         def_sh_tex(srna);
1426 }
1427
1428 static void def_sh_tex_checker(StructRNA *srna)
1429 {
1430         RNA_def_struct_sdna_from(srna, "NodeTexChecker", "storage");
1431         def_sh_tex(srna);
1432 }
1433
1434 static void def_sh_tex_magic(StructRNA *srna)
1435 {
1436         PropertyRNA *prop;
1437         
1438         RNA_def_struct_sdna_from(srna, "NodeTexMagic", "storage");
1439         def_sh_tex(srna);
1440
1441         prop = RNA_def_property(srna, "turbulence_depth", PROP_INT, PROP_NONE);
1442         RNA_def_property_int_sdna(prop, NULL, "depth");
1443         RNA_def_property_range(prop, 0, 10);
1444         RNA_def_property_ui_text(prop, "Depth", "Level of detail in the added turbulent noise");
1445         RNA_def_property_update(prop, 0, "rna_Node_update");
1446 }
1447
1448 static void def_sh_tex_musgrave(StructRNA *srna)
1449 {
1450         static EnumPropertyItem prop_musgrave_type[] = {
1451                 {SHD_MUSGRAVE_MULTIFRACTAL, "MULTIFRACTAL", 0, "Multifractal", ""},
1452                 {SHD_MUSGRAVE_RIDGED_MULTIFRACTAL, "RIDGED_MULTIFRACTAL", 0, "Ridged Multifractal", ""},
1453                 {SHD_MUSGRAVE_HYBRID_MULTIFRACTAL, "HYBRID_MULTIFRACTAL", 0, "Hybrid Multifractal", ""},
1454                 {SHD_MUSGRAVE_FBM, "FBM", 0, "fBM", ""},
1455                 {SHD_MUSGRAVE_HETERO_TERRAIN, "HETERO_TERRAIN", 0, "Hetero Terrain", ""},
1456                 {0, NULL, 0, NULL, NULL}};
1457
1458         PropertyRNA *prop;
1459         
1460         RNA_def_struct_sdna_from(srna, "NodeTexMusgrave", "storage");
1461         def_sh_tex(srna);
1462
1463         prop = RNA_def_property(srna, "musgrave_type", PROP_ENUM, PROP_NONE);
1464         RNA_def_property_enum_sdna(prop, NULL, "musgrave_type");
1465         RNA_def_property_enum_items(prop, prop_musgrave_type);
1466         RNA_def_property_ui_text(prop, "Type", "");
1467         RNA_def_property_update(prop, 0, "rna_Node_update");
1468 }
1469
1470 static void def_sh_tex_voronoi(StructRNA *srna)
1471 {
1472         static EnumPropertyItem prop_coloring_items[] = {
1473                 {SHD_VORONOI_INTENSITY, "INTENSITY", 0, "Intensity", "Only calculate intensity"},
1474                 {SHD_VORONOI_CELLS, "CELLS", 0, "Cells", "Color cells by position"},
1475                 {0, NULL, 0, NULL, NULL}};
1476
1477         PropertyRNA *prop;
1478         
1479         RNA_def_struct_sdna_from(srna, "NodeTexVoronoi", "storage");
1480         def_sh_tex(srna);
1481
1482         prop = RNA_def_property(srna, "coloring", PROP_ENUM, PROP_NONE);
1483         RNA_def_property_enum_sdna(prop, NULL, "coloring");
1484         RNA_def_property_enum_items(prop, prop_coloring_items);
1485         RNA_def_property_ui_text(prop, "Coloring", "");
1486         RNA_def_property_update(prop, 0, "rna_Node_update");
1487 }
1488
1489 static void def_sh_tex_wave(StructRNA *srna)
1490 {
1491         static EnumPropertyItem prop_wave_type_items[] = {
1492         {SHD_WAVE_BANDS, "BANDS", 0, "Bands", "Use standard wave texture in bands"},
1493         {SHD_WAVE_RINGS, "RINGS", 0, "Rings", "Use wave texture in rings"},
1494         {0, NULL, 0, NULL, NULL}};
1495
1496         PropertyRNA *prop;
1497         
1498         RNA_def_struct_sdna_from(srna, "NodeTexWave", "storage");
1499         def_sh_tex(srna);
1500
1501         prop = RNA_def_property(srna, "wave_type", PROP_ENUM, PROP_NONE);
1502         RNA_def_property_enum_sdna(prop, NULL, "wave_type");
1503         RNA_def_property_enum_items(prop, prop_wave_type_items);
1504         RNA_def_property_ui_text(prop, "Wave Type", "");
1505         RNA_def_property_update(prop, 0, "rna_Node_update");
1506 }
1507
1508 static void def_glossy(StructRNA *srna)
1509 {
1510         PropertyRNA *prop;
1511         
1512         prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
1513         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1514         RNA_def_property_enum_items(prop, node_glossy_items);
1515         RNA_def_property_ui_text(prop, "Distribution", "");
1516         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1517 }
1518
1519 /* -- Compositor Nodes ------------------------------------------------------ */
1520
1521 static void def_cmp_alpha_over(StructRNA *srna)
1522 {
1523         PropertyRNA *prop;
1524         
1525         /* XXX: Tooltip */
1526         prop = RNA_def_property(srna, "use_premultiply", PROP_BOOLEAN, PROP_NONE);
1527         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 1);
1528         RNA_def_property_ui_text(prop, "Convert Premul", "");
1529         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1530         
1531         RNA_def_struct_sdna_from(srna, "NodeTwoFloats", "storage");
1532         
1533         prop = RNA_def_property(srna, "premul", PROP_FLOAT, PROP_NONE);
1534         RNA_def_property_float_sdna(prop, NULL, "x");
1535         RNA_def_property_range(prop, 0.0f, 1.0f);
1536         RNA_def_property_ui_text(prop, "Premul", "Mix Factor");
1537         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1538 }
1539
1540 static void def_cmp_hue_saturation(StructRNA *srna)
1541 {
1542         PropertyRNA *prop;
1543
1544         RNA_def_struct_sdna_from(srna, "NodeHueSat", "storage");
1545         
1546         prop = RNA_def_property(srna, "color_hue", PROP_FLOAT, PROP_NONE);
1547         RNA_def_property_float_sdna(prop, NULL, "hue");
1548         RNA_def_property_range(prop, 0.0f, 1.0f);
1549         RNA_def_property_ui_text(prop, "Hue", "");
1550         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1551         
1552         prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_NONE);
1553         RNA_def_property_float_sdna(prop, NULL, "sat");
1554         RNA_def_property_range(prop, 0.0f, 2.0f);
1555         RNA_def_property_ui_text(prop, "Saturation", "");
1556         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1557         
1558         prop = RNA_def_property(srna, "color_value", PROP_FLOAT, PROP_NONE);
1559         RNA_def_property_float_sdna(prop, NULL, "val");
1560         RNA_def_property_range(prop, 0.0f, 2.0f);
1561         RNA_def_property_ui_text(prop, "Value", "");
1562         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1563 }
1564
1565 static void def_cmp_blur(StructRNA *srna)
1566 {
1567         PropertyRNA *prop;
1568         
1569         static EnumPropertyItem filter_type_items[] = {
1570                 {R_FILTER_BOX,        "FLAT",       0, "Flat",          ""},
1571                 {R_FILTER_TENT,       "TENT",       0, "Tent",          ""},
1572                 {R_FILTER_QUAD,       "QUAD",       0, "Quadratic",     ""},
1573                 {R_FILTER_CUBIC,      "CUBIC",      0, "Cubic",         ""},
1574                 {R_FILTER_GAUSS,      "GAUSS",      0, "Gaussian",      ""},
1575                 {R_FILTER_FAST_GAUSS, "FAST_GAUSS", 0, "Fast Gaussian", ""},
1576                 {R_FILTER_CATROM,     "CATROM",     0, "Catrom",        ""},
1577                 {R_FILTER_MITCH,      "MITCH",      0, "Mitch",         ""},
1578                 {0, NULL, 0, NULL, NULL}};
1579
1580         static EnumPropertyItem aspect_correction_type_items[] = {
1581                 {CMP_NODE_BLUR_ASPECT_NONE,     "NONE", 0,      "None", ""},
1582                 {CMP_NODE_BLUR_ASPECT_Y,        "Y",    0,      "Y",    ""},
1583                 {CMP_NODE_BLUR_ASPECT_X,        "X",    0,      "X",    ""},
1584                 {0, NULL, 0, NULL, NULL}};
1585
1586         RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
1587         
1588         prop = RNA_def_property(srna, "size_x", PROP_INT, PROP_NONE);
1589         RNA_def_property_int_sdna(prop, NULL, "sizex");
1590         RNA_def_property_range(prop, 0, 2048);
1591         RNA_def_property_ui_text(prop, "Size X", "");
1592         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1593         
1594         prop = RNA_def_property(srna, "size_y", PROP_INT, PROP_NONE);
1595         RNA_def_property_int_sdna(prop, NULL, "sizey");
1596         RNA_def_property_range(prop, 0, 2048);
1597         RNA_def_property_ui_text(prop, "Size Y", "");
1598         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1599
1600         prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
1601         RNA_def_property_boolean_sdna(prop, NULL, "relative", 1);
1602         RNA_def_property_ui_text(prop, "Relative", "Use relative (percent) values to define blur radius");
1603         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1604         
1605         prop = RNA_def_property(srna, "aspect_correction", PROP_ENUM, PROP_NONE);
1606         RNA_def_property_enum_sdna(prop, NULL, "aspect");
1607         RNA_def_property_enum_items(prop, aspect_correction_type_items);
1608         RNA_def_property_ui_text(prop, "Aspect Correction", "Type of aspect correction to use");
1609         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1610
1611         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
1612         RNA_def_property_float_sdna(prop, NULL, "fac");
1613         RNA_def_property_range(prop, 0.0f, 2.0f);
1614         RNA_def_property_ui_text(prop, "Factor", "");
1615         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1616         
1617         prop = RNA_def_property(srna, "factor_x", PROP_FLOAT, PROP_PERCENTAGE);
1618         RNA_def_property_float_sdna(prop, NULL, "percentx");
1619         RNA_def_property_range(prop, 0.0f, 100.0f);
1620         RNA_def_property_ui_text(prop, "Relative Size X", "");
1621         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1622         
1623         prop = RNA_def_property(srna, "factor_y", PROP_FLOAT, PROP_PERCENTAGE);
1624         RNA_def_property_float_sdna(prop, NULL, "percenty");
1625         RNA_def_property_range(prop, 0.0f, 100.0f);
1626         RNA_def_property_ui_text(prop, "Relative Size Y", "");
1627         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1628         
1629         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
1630         RNA_def_property_enum_sdna(prop, NULL, "filtertype");
1631         RNA_def_property_enum_items(prop, filter_type_items);
1632         RNA_def_property_ui_text(prop, "Filter Type", "");
1633         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1634         
1635         prop = RNA_def_property(srna, "use_bokeh", PROP_BOOLEAN, PROP_NONE);
1636         RNA_def_property_boolean_sdna(prop, NULL, "bokeh", 1);
1637         RNA_def_property_ui_text(prop, "Bokeh", "Use circular filter (slower)");
1638         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1639         
1640         prop = RNA_def_property(srna, "use_gamma_correction", PROP_BOOLEAN, PROP_NONE);
1641         RNA_def_property_boolean_sdna(prop, NULL, "gamma", 1);
1642         RNA_def_property_ui_text(prop, "Gamma", "Apply filter on gamma corrected values");
1643         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1644         
1645 }
1646
1647 static void def_cmp_filter(StructRNA *srna)
1648 {
1649         PropertyRNA *prop;
1650
1651         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
1652         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1653         RNA_def_property_enum_items(prop, node_filter_items);
1654         RNA_def_property_ui_text(prop, "Filter Type", "");
1655         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1656 }
1657
1658 static void def_cmp_map_value(StructRNA *srna)
1659 {
1660         PropertyRNA *prop;
1661         
1662         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
1663         
1664         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
1665         RNA_def_property_float_sdna(prop, NULL, "loc");
1666         RNA_def_property_array(prop, 1);
1667         RNA_def_property_range(prop, -1000.0f, 1000.0f);
1668         RNA_def_property_ui_text(prop, "Offset", "");
1669         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1670         
1671         prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
1672         RNA_def_property_float_sdna(prop, NULL, "size");
1673         RNA_def_property_array(prop, 1);
1674         RNA_def_property_range(prop, -1000.0f, 1000.0f);
1675         RNA_def_property_ui_text(prop, "Size", "");
1676         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1677         
1678         prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
1679         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
1680         RNA_def_property_ui_text(prop, "Use Minimum", "");
1681         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1682         
1683         prop = RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
1684         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
1685         RNA_def_property_ui_text(prop, "Use Maximum", "");
1686         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1687         
1688         prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
1689         RNA_def_property_float_sdna(prop, NULL, "min");
1690         RNA_def_property_array(prop, 1);
1691         RNA_def_property_range(prop, -1000.0f, 1000.0f);
1692         RNA_def_property_ui_text(prop, "Minimum", "");
1693         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1694         
1695         prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
1696         RNA_def_property_float_sdna(prop, NULL, "max");
1697         RNA_def_property_array(prop, 1);
1698         RNA_def_property_range(prop, -1000.0f, 1000.0f);
1699         RNA_def_property_ui_text(prop, "Maximum", "");
1700         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1701 }
1702
1703 static void def_cmp_vector_blur(StructRNA *srna)
1704 {
1705         PropertyRNA *prop;
1706         
1707         RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
1708         
1709         prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
1710         RNA_def_property_int_sdna(prop, NULL, "samples");
1711         RNA_def_property_range(prop, 1, 256);
1712         RNA_def_property_ui_text(prop, "Samples", "");
1713         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1714         
1715         prop = RNA_def_property(srna, "speed_min", PROP_INT, PROP_NONE);
1716         RNA_def_property_int_sdna(prop, NULL, "minspeed");
1717         RNA_def_property_range(prop, 0, 1024);
1718         RNA_def_property_ui_text(prop, "Min Speed",
1719                                  "Minimum speed for a pixel to be blurred (used to separate background from foreground)");
1720         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1721                 
1722         prop = RNA_def_property(srna, "speed_max", PROP_INT, PROP_NONE);
1723         RNA_def_property_int_sdna(prop, NULL, "maxspeed");
1724         RNA_def_property_range(prop, 0, 1024);
1725         RNA_def_property_ui_text(prop, "Max Speed", "Maximum speed, or zero for none");
1726         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1727         
1728         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
1729         RNA_def_property_float_sdna(prop, NULL, "fac");
1730         RNA_def_property_range(prop, 0.0, 20.0);
1731         RNA_def_property_ui_range(prop, 0.0, 2.0, 1.0, 2);
1732         RNA_def_property_ui_text(prop, "Blur Factor",
1733                                  "Scaling factor for motion vectors (actually, 'shutter speed', in frames)");
1734         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1735         
1736         prop = RNA_def_property(srna, "use_curved", PROP_BOOLEAN, PROP_NONE);
1737         RNA_def_property_boolean_sdna(prop, NULL, "curved", 1);
1738         RNA_def_property_ui_text(prop, "Curved", "Interpolate between frames in a Bezier curve, rather than linearly");
1739         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1740 }
1741
1742 static void def_cmp_levels(StructRNA *srna)
1743 {
1744         PropertyRNA *prop;
1745         
1746         static EnumPropertyItem channel_items[] = {
1747                 {1, "COMBINED_RGB", 0, "C", "Combined RGB"},
1748                 {2, "RED", 0, "R", "Red Channel"},
1749                 {3, "GREEN", 0, "G", "Green Channel"},
1750                 {4, "BLUE", 0, "B", "Blue Channel"},
1751                 {5, "LUMINANCE", 0, "L", "Luminance Channel"},
1752                 {0, NULL, 0, NULL, NULL}};
1753         
1754         prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
1755         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1756         RNA_def_property_enum_items(prop, channel_items);
1757         RNA_def_property_ui_text(prop, "Channel", "");
1758         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1759 }
1760
1761 static void def_cmp_image(StructRNA *srna)
1762 {
1763         PropertyRNA *prop;
1764         
1765 #if 0
1766         static EnumPropertyItem type_items[] = {
1767                 {IMA_SRC_FILE,      "IMAGE",     0, "Image",     ""},
1768                 {IMA_SRC_MOVIE,     "MOVIE",     "Movie",     ""},
1769                 {IMA_SRC_SEQUENCE,  "SEQUENCE",  "Sequence",  ""},
1770                 {IMA_SRC_GENERATED, "GENERATED", "Generated", ""},
1771                 {0, NULL, 0, NULL, NULL}};
1772 #endif
1773         
1774         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1775         RNA_def_property_pointer_sdna(prop, NULL, "id");
1776         RNA_def_property_struct_type(prop, "Image");
1777         RNA_def_property_flag(prop, PROP_EDITABLE);
1778         RNA_def_property_ui_text(prop, "Image", "");
1779         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1780         
1781         RNA_def_struct_sdna_from(srna, "ImageUser", "storage");
1782         
1783         prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
1784         RNA_def_property_int_sdna(prop, NULL, "frames");
1785         RNA_def_property_range(prop, 0, MAXFRAMEF);
1786         RNA_def_property_ui_text(prop, "Frames", "Number of images of a movie to use"); /* copied from the rna_image.c */
1787         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1788         
1789         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
1790         RNA_def_property_int_sdna(prop, NULL, "sfra");
1791         RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
1792                  /* copied from the rna_image.c */
1793         RNA_def_property_ui_text(prop, "Start Frame",
1794                                  "Global starting frame of the movie/sequence, assuming first picture has a #1");
1795         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1796         
1797         prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
1798         RNA_def_property_int_sdna(prop, NULL, "offset");
1799         RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
1800                 /* copied from the rna_image.c */
1801         RNA_def_property_ui_text(prop, "Offset", "Offset the number of the frame to use in the animation");
1802         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1803         
1804         prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
1805         RNA_def_property_boolean_sdna(prop, NULL, "cycl", 1);
1806         RNA_def_property_ui_text(prop, "Cyclic", "Cycle the images in the movie"); /* copied from the rna_image.c */
1807         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1808         
1809         prop = RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
1810         RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_ANIM_ALWAYS);
1811                 /* copied from the rna_image.c */
1812         RNA_def_property_ui_text(prop, "Auto-Refresh", "Always refresh image on frame changes");
1813         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1814 }
1815
1816 static void def_cmp_render_layers(StructRNA *srna)
1817 {
1818         PropertyRNA *prop;
1819         
1820         prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
1821         RNA_def_property_pointer_sdna(prop, NULL, "id");
1822         RNA_def_property_pointer_funcs(prop, NULL, "rna_Node_scene_set", NULL, NULL);
1823         RNA_def_property_struct_type(prop, "Scene");
1824         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_ID_SELF_CHECK);
1825         RNA_def_property_ui_text(prop, "Scene", "");
1826         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1827         
1828         prop = RNA_def_property(srna, "layer", PROP_ENUM, PROP_NONE);
1829         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1830         RNA_def_property_enum_items(prop, prop_scene_layer_items);
1831         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Node_scene_layer_itemf");
1832         RNA_def_property_ui_text(prop, "Layer", "");
1833         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1834 }
1835
1836 static void rna_def_cmp_output_file_slot_file(BlenderRNA *brna)
1837 {
1838         StructRNA *srna;
1839         PropertyRNA *prop;
1840         
1841         srna = RNA_def_struct(brna, "NodeOutputFileSlotFile", NULL);
1842         RNA_def_struct_sdna(srna, "NodeImageMultiFileSocket");
1843         RNA_def_struct_ui_text(srna, "Output File Slot", "Single layer file slot of the file output node");
1844         
1845         prop = RNA_def_property(srna, "use_node_format", PROP_BOOLEAN, PROP_NONE);
1846         RNA_def_property_boolean_sdna(prop, NULL, "use_node_format", 1);
1847         RNA_def_property_ui_text(prop, "Use Node Format", "");
1848         RNA_def_property_update(prop, NC_NODE|NA_EDITED, NULL);
1849         
1850         prop = RNA_def_property(srna, "format", PROP_POINTER, PROP_NONE);
1851         RNA_def_property_struct_type(prop, "ImageFormatSettings");
1852         
1853         prop = RNA_def_property(srna, "path", PROP_STRING, PROP_FILEPATH);
1854         RNA_def_property_string_sdna(prop, NULL, "path");
1855         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_NodeOutputFileSlotFile_path_set");
1856         RNA_def_struct_name_property(srna, prop);
1857         RNA_def_property_ui_text(prop, "Path", "Subpath used for this slot");
1858         RNA_def_property_update(prop, NC_NODE|NA_EDITED, NULL);
1859 }
1860 static void rna_def_cmp_output_file_slot_layer(BlenderRNA *brna)
1861 {
1862         StructRNA *srna;
1863         PropertyRNA *prop;
1864         
1865         srna = RNA_def_struct(brna, "NodeOutputFileSlotLayer", NULL);
1866         RNA_def_struct_sdna(srna, "NodeImageMultiFileSocket");
1867         RNA_def_struct_ui_text(srna, "Output File Layer Slot", "Multilayer slot of the file output node");
1868         
1869         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1870         RNA_def_property_string_sdna(prop, NULL, "layer");
1871         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_NodeOutputFileSlotLayer_name_set");
1872         RNA_def_struct_name_property(srna, prop);
1873         RNA_def_property_ui_text(prop, "Name", "OpenEXR layer name used for this slot");
1874         RNA_def_property_update(prop, NC_NODE|NA_EDITED, NULL);
1875 }
1876 static void def_cmp_output_file(StructRNA *srna)
1877 {
1878         PropertyRNA *prop;
1879         
1880         RNA_def_struct_sdna_from(srna, "NodeImageMultiFile", "storage");
1881         
1882         prop = RNA_def_property(srna, "base_path", PROP_STRING, PROP_FILEPATH);
1883         RNA_def_property_string_sdna(prop, NULL, "base_path");
1884         RNA_def_property_ui_text(prop, "Base Path", "Base output path for the image");
1885         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1886         
1887         prop = RNA_def_property(srna, "active_input_index", PROP_INT, PROP_NONE);
1888         RNA_def_property_int_sdna(prop, NULL, "active_input");
1889         RNA_def_property_ui_text(prop, "Active Input Index", "Active input index in details view list");
1890         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1891         
1892         prop = RNA_def_property(srna, "format", PROP_POINTER, PROP_NONE);
1893         RNA_def_property_struct_type(prop, "ImageFormatSettings");
1894         
1895         /* XXX using two different collections here for the same basic DNA list!
1896          * Details of the output slots depend on whether the node is in Multilayer EXR mode.
1897          */
1898         
1899         prop = RNA_def_property(srna, "file_slots", PROP_COLLECTION, PROP_NONE);
1900         RNA_def_property_collection_funcs(prop, "rna_NodeOutputFile_slots_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end",
1901                                           "rna_NodeOutputFile_slot_file_get", NULL, NULL, NULL, NULL);
1902         RNA_def_property_struct_type(prop, "NodeOutputFileSlotFile");
1903         RNA_def_property_ui_text(prop, "File Slots", "");
1904         
1905         prop = RNA_def_property(srna, "layer_slots", PROP_COLLECTION, PROP_NONE);
1906         RNA_def_property_collection_funcs(prop, "rna_NodeOutputFile_slots_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end",
1907                                           "rna_NodeOutputFile_slot_layer_get", NULL, NULL, NULL, NULL);
1908         RNA_def_property_struct_type(prop, "NodeOutputFileSlotLayer");
1909         RNA_def_property_ui_text(prop, "EXR Layer Slots", "");
1910 }
1911
1912 static void def_cmp_dilate_erode(StructRNA *srna)
1913 {
1914         PropertyRNA *prop;
1915         
1916         prop = RNA_def_property(srna, "distance", PROP_INT, PROP_NONE);
1917         RNA_def_property_int_sdna(prop, NULL, "custom2");
1918         RNA_def_property_range(prop, -100, 100);
1919         RNA_def_property_ui_text(prop, "Distance", "Distance to grow/shrink (number of iterations)");
1920         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1921 }
1922
1923 static void def_cmp_scale(StructRNA *srna)
1924 {
1925         PropertyRNA *prop;
1926         
1927         static EnumPropertyItem space_items[] = {
1928                 {0, "RELATIVE",   0, "Relative",   ""},
1929                 {1, "ABSOLUTE",   0, "Absolute",   ""},
1930                 {2, "SCENE_SIZE", 0, "Scene Size", ""},
1931                 {3, "RENDER_SIZE", 0, "Render Size", ""},
1932                 {0, NULL, 0, NULL, NULL}};
1933         
1934         prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
1935         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1936         RNA_def_property_enum_items(prop, space_items);
1937         RNA_def_property_ui_text(prop, "Space", "Coordinate space to scale relative to");
1938         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1939 }
1940
1941 static void def_cmp_rotate(StructRNA *srna)
1942 {
1943         PropertyRNA *prop;
1944         
1945         static EnumPropertyItem rotate_items[] = {
1946                 {0, "NEAREST",   0, "Nearest",   ""},
1947                 {1, "BILINEAR",   0, "Bilinear",   ""},
1948                 {2, "BICUBIC", 0, "Bicubic", ""},
1949                 {0, NULL, 0, NULL, NULL}};
1950         
1951         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
1952         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1953         RNA_def_property_enum_items(prop, rotate_items);
1954         RNA_def_property_ui_text(prop, "Filter", "Method to use to filter rotation");
1955         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1956 }
1957
1958 static void def_cmp_diff_matte(StructRNA *srna)
1959 {
1960         PropertyRNA *prop;
1961
1962         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
1963         
1964         prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_NONE);
1965         RNA_def_property_float_sdna(prop, NULL, "t1");
1966         RNA_def_property_float_funcs(prop, NULL, "rna_difference_matte_t1_set", NULL);
1967         RNA_def_property_range(prop, 0.0f, 1.0f);
1968         RNA_def_property_ui_text(prop, "Tolerance", "Color distances below this threshold are keyed");
1969         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1970         
1971         prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
1972         RNA_def_property_float_sdna(prop, NULL, "t2");
1973         RNA_def_property_float_funcs(prop, NULL, "rna_difference_matte_t2_set", NULL);
1974         RNA_def_property_range(prop, 0.0f, 1.0f);
1975         RNA_def_property_ui_text(prop, "Falloff", "Color distances below this additional threshold are partially keyed");
1976         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1977 }
1978
1979 static void def_cmp_color_matte(StructRNA *srna)
1980 {
1981         PropertyRNA *prop;
1982         
1983         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
1984
1985         prop = RNA_def_property(srna, "color_hue", PROP_FLOAT, PROP_NONE);
1986         RNA_def_property_float_sdna(prop, NULL, "t1");
1987         RNA_def_property_range(prop, 0.0f, 1.0f);
1988         RNA_def_property_ui_text(prop, "H", "Hue tolerance for colors to be considered a keying color");
1989         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1990         
1991         prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_NONE);
1992         RNA_def_property_float_sdna(prop, NULL, "t2");
1993         RNA_def_property_range(prop, 0.0f, 1.0f);
1994         RNA_def_property_ui_text(prop, "S", "Saturation Tolerance for the color");
1995         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
1996         
1997         prop = RNA_def_property(srna, "color_value", PROP_FLOAT, PROP_NONE);
1998         RNA_def_property_float_sdna(prop, NULL, "t3");
1999         RNA_def_property_range(prop, 0.0f, 1.0f);
2000         RNA_def_property_ui_text(prop, "V", "Value Tolerance for the color");
2001         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2002 }
2003
2004 static void def_cmp_distance_matte(StructRNA *srna)
2005 {
2006         PropertyRNA *prop;
2007         
2008         static EnumPropertyItem color_space_items[] = {
2009                 {1, "RGB", 0, "RGB", "RGB color space"},
2010                 {2, "YCC", 0, "YCC", "YCbCr Suppression"},
2011                 {0, NULL, 0, NULL, NULL}};
2012
2013         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2014
2015         prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
2016         RNA_def_property_enum_sdna(prop, NULL, "channel");
2017         RNA_def_property_enum_items(prop, color_space_items);
2018         RNA_def_property_ui_text(prop, "Channel", "");
2019         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2020
2021         
2022         prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_NONE);
2023         RNA_def_property_float_sdna(prop, NULL, "t1");
2024         RNA_def_property_float_funcs(prop, NULL, "rna_distance_matte_t1_set", NULL);
2025         RNA_def_property_range(prop, 0.0f, 1.0f);
2026         RNA_def_property_ui_text(prop, "Tolerance", "Color distances below this threshold are keyed");
2027         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2028         
2029         prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
2030         RNA_def_property_float_sdna(prop, NULL, "t2");
2031         RNA_def_property_float_funcs(prop, NULL, "rna_distance_matte_t2_set", NULL);
2032         RNA_def_property_range(prop, 0.0f, 1.0f);
2033         RNA_def_property_ui_text(prop, "Falloff", "Color distances below this additional threshold are partially keyed");
2034         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2035 }
2036
2037 static void def_cmp_color_spill(StructRNA *srna)
2038 {
2039         PropertyRNA *prop;
2040
2041         static EnumPropertyItem channel_items[] = {
2042                 {1, "R", 0, "R", "Red Spill Suppression"},
2043                 {2, "G", 0, "G", "Green Spill Suppression"},
2044                 {3, "B", 0, "B", "Blue Spill Suppression"},
2045                 {0, NULL, 0, NULL, NULL}};
2046
2047         static EnumPropertyItem limit_channel_items[] = {
2048                 {1, "R", 0, "R", "Limit by Red"},
2049                 {2, "G", 0, "G", "Limit by Green"},
2050                 {3, "B", 0, "B", "Limit by Blue"},
2051                 {0, NULL, 0, NULL, NULL}};
2052
2053         static EnumPropertyItem algorithm_items[] = {
2054                 {0, "SIMPLE", 0, "Simple", "Simple Limit Algorithm"},
2055                 {1, "AVERAGE", 0, "Average", "Average Limit Algorithm"},
2056                 {0, NULL, 0, NULL, NULL}};
2057         
2058         prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
2059         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2060         RNA_def_property_enum_items(prop, channel_items);
2061         RNA_def_property_ui_text(prop, "Channel", "");
2062         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2063         
2064         prop = RNA_def_property(srna, "limit_method", PROP_ENUM, PROP_NONE);
2065         RNA_def_property_enum_sdna(prop, NULL, "custom2");
2066         RNA_def_property_enum_items(prop, algorithm_items);
2067         RNA_def_property_ui_text(prop, "Algorithm", "");
2068         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2069
2070         RNA_def_struct_sdna_from(srna, "NodeColorspill", "storage");
2071
2072         prop = RNA_def_property(srna, "limit_channel", PROP_ENUM, PROP_NONE);
2073         RNA_def_property_enum_sdna(prop, NULL, "limchan");
2074         RNA_def_property_enum_items(prop, limit_channel_items);
2075         RNA_def_property_ui_text(prop, "Limit Channel", "");
2076         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2077
2078         prop = RNA_def_property(srna, "ratio", PROP_FLOAT, PROP_NONE);
2079         RNA_def_property_float_sdna(prop, NULL, "limscale");
2080         RNA_def_property_range(prop, 0.5f, 1.5f);
2081         RNA_def_property_ui_text(prop, "Ratio", "Scale limit by value");
2082         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2083
2084         prop = RNA_def_property(srna, "use_unspill", PROP_BOOLEAN, PROP_NONE);
2085         RNA_def_property_boolean_sdna(prop, NULL, "unspill", 0);
2086         RNA_def_property_ui_text(prop, "Unspill", "Compensate all channels (differently) by hand");
2087         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2088
2089         prop = RNA_def_property(srna, "unspill_red", PROP_FLOAT, PROP_NONE);
2090         RNA_def_property_float_sdna(prop, NULL, "uspillr");
2091         RNA_def_property_range(prop, 0.0f, 1.5f);
2092         RNA_def_property_ui_text(prop, "R", "Red spillmap scale");
2093         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2094
2095         prop = RNA_def_property(srna, "unspill_green", PROP_FLOAT, PROP_NONE);
2096         RNA_def_property_float_sdna(prop, NULL, "uspillg");
2097         RNA_def_property_range(prop, 0.0f, 1.5f);
2098         RNA_def_property_ui_text(prop, "G", "Green spillmap scale");
2099         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2100
2101         prop = RNA_def_property(srna, "unspill_blue", PROP_FLOAT, PROP_NONE);
2102         RNA_def_property_float_sdna(prop, NULL, "uspillb");
2103         RNA_def_property_range(prop, 0.0f, 1.5f);
2104         RNA_def_property_ui_text(prop, "B", "Blue spillmap scale");
2105         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2106 }
2107
2108 static void def_cmp_luma_matte(StructRNA *srna)
2109 {
2110         PropertyRNA *prop;
2111         
2112         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2113         
2114         prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
2115         RNA_def_property_float_sdna(prop, NULL, "t1");
2116         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t1_set", NULL);
2117         RNA_def_property_range(prop, 0.0f, 1.0f);
2118         RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
2119         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2120         
2121         prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
2122         RNA_def_property_float_sdna(prop, NULL, "t2");
2123         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
2124         RNA_def_property_range(prop, 0.0f, 1.0f);
2125         RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
2126         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2127 }
2128
2129 static void def_cmp_chroma_matte(StructRNA *srna)
2130 {
2131         PropertyRNA *prop;
2132         
2133         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2134         
2135         prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_ANGLE);
2136         RNA_def_property_float_sdna(prop, NULL, "t1");
2137         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t1_set", NULL);
2138         RNA_def_property_range(prop, DEG2RADF(1.0f), DEG2RADF(80.0f));
2139         RNA_def_property_ui_text(prop, "Acceptance", "Tolerance for a color to be considered a keying color");
2140         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2141         
2142         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_ANGLE);
2143         RNA_def_property_float_sdna(prop, NULL, "t2");
2144         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
2145         RNA_def_property_range(prop, 0.0f, DEG2RADF(30.0f));
2146         RNA_def_property_ui_text(prop, "Cutoff", "Tolerance below which colors will be considered as exact matches");
2147         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2148
2149         prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_NONE);
2150         RNA_def_property_float_sdna(prop, NULL, "fsize");
2151         RNA_def_property_range(prop, 0.0f, 1.0f);
2152         RNA_def_property_ui_text(prop, "Lift", "Alpha lift");
2153         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2154         
2155         prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_NONE);
2156         RNA_def_property_float_sdna(prop, NULL, "fstrength");
2157         RNA_def_property_range(prop, 0.0f, 1.0f);
2158         RNA_def_property_ui_text(prop, "Falloff", "Alpha falloff");
2159         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2160         
2161         prop = RNA_def_property(srna, "shadow_adjust", PROP_FLOAT, PROP_NONE);
2162         RNA_def_property_float_sdna(prop, NULL, "t3");
2163         RNA_def_property_range(prop, 0.0f, 1.0f);
2164         RNA_def_property_ui_text(prop, "Shadow Adjust", "Adjusts the brightness of any shadows captured");
2165         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2166 }
2167
2168 static void def_cmp_channel_matte(StructRNA *srna)
2169 {
2170         PropertyRNA *prop;
2171         
2172         static EnumPropertyItem color_space_items[] = {
2173                 {CMP_NODE_CHANNEL_MATTE_CS_RGB, "RGB", 0, "RGB",   "RGB Color Space"},
2174                 {CMP_NODE_CHANNEL_MATTE_CS_HSV, "HSV", 0, "HSV",   "HSV Color Space"},
2175                 {CMP_NODE_CHANNEL_MATTE_CS_YUV, "YUV", 0, "YUV",   "YUV Color Space"},
2176                 {CMP_NODE_CHANNEL_MATTE_CS_YCC, "YCC", 0, "YCbCr", "YCbCr Color Space"},
2177                 {0, NULL, 0, NULL, NULL}};
2178
2179         static EnumPropertyItem algorithm_items[] = {
2180                 {0, "SINGLE", 0, "Single", "Limit by single channel"},
2181                 {1, "MAX", 0, "Max", "Limit by max of other channels "},
2182                 {0, NULL, 0, NULL, NULL}};
2183         
2184         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
2185         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2186         RNA_def_property_enum_items(prop, color_space_items);
2187         RNA_def_property_ui_text(prop, "Color Space", "");
2188         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2189         
2190         prop = RNA_def_property(srna, "matte_channel", PROP_ENUM, PROP_NONE);
2191         RNA_def_property_enum_sdna(prop, NULL, "custom2");
2192         RNA_def_property_enum_items(prop, prop_tri_channel_items);
2193         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Node_channel_itemf");
2194         RNA_def_property_ui_text(prop, "Channel", "Channel used to determine matte");
2195         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2196
2197         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2198
2199         prop = RNA_def_property(srna, "limit_method", PROP_ENUM, PROP_NONE);
2200         RNA_def_property_enum_sdna(prop, NULL, "algorithm");
2201         RNA_def_property_enum_items(prop, algorithm_items);
2202         RNA_def_property_ui_text(prop, "Algorithm", "Algorithm to use to limit channel");
2203         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2204
2205         prop = RNA_def_property(srna, "limit_channel", PROP_ENUM, PROP_NONE);
2206         RNA_def_property_enum_sdna(prop, NULL, "channel");
2207         RNA_def_property_enum_items(prop, prop_tri_channel_items);
2208         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Node_channel_itemf");
2209         RNA_def_property_ui_text(prop, "Limit Channel", "Limit by this channel's value");
2210         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2211         
2212         prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
2213         RNA_def_property_float_sdna(prop, NULL, "t1");
2214         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t1_set", NULL);
2215         RNA_def_property_range(prop, 0.0f, 1.0f);
2216         RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
2217         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2218         
2219         prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
2220         RNA_def_property_float_sdna(prop, NULL, "t2");
2221         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
2222         RNA_def_property_range(prop, 0.0f, 1.0f);
2223         RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
2224         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2225 }
2226
2227 static void def_cmp_flip(StructRNA *srna)
2228 {
2229         PropertyRNA *prop;
2230         
2231         prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
2232         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2233         RNA_def_property_enum_items(prop, node_flip_items);
2234         RNA_def_property_ui_text(prop, "Axis", "");
2235         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2236 }
2237
2238 static void def_cmp_splitviewer(StructRNA *srna)
2239 {
2240         PropertyRNA *prop;
2241         
2242         static EnumPropertyItem axis_items[] = {
2243                 {0, "X",  0, "X",     ""},
2244                 {1, "Y",  0, "Y",     ""},
2245                 {0, NULL, 0, NULL, NULL}};
2246         
2247         prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
2248         RNA_def_property_enum_sdna(prop, NULL, "custom2");
2249         RNA_def_property_enum_items(prop, axis_items);
2250         RNA_def_property_ui_text(prop, "Axis", "");
2251         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2252
2253         prop = RNA_def_property(srna, "factor", PROP_INT, PROP_FACTOR);
2254         RNA_def_property_int_sdna(prop, NULL, "custom1");
2255         RNA_def_property_range(prop, 0, 100);
2256         RNA_def_property_ui_text(prop, "Factor", "");
2257         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2258 }
2259
2260 static void def_cmp_id_mask(StructRNA *srna)
2261 {
2262         PropertyRNA *prop;
2263         
2264         prop = RNA_def_property(srna, "index", PROP_INT, PROP_NONE);
2265         RNA_def_property_int_sdna(prop, NULL, "custom1");
2266         RNA_def_property_range(prop, 0, 32767);
2267         RNA_def_property_ui_text(prop, "Index", "Pass index number to convert to alpha");
2268         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2269
2270         prop = RNA_def_property(srna, "use_smooth_mask", PROP_BOOLEAN, PROP_NONE);
2271         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 0);
2272         RNA_def_property_ui_text(prop, "Smooth Mask", "Apply an anti-aliasing filter to the mask");
2273         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2274 }
2275
2276 static void def_cmp_double_edge_mask(StructRNA * srna)
2277 {
2278         PropertyRNA *prop;
2279
2280         static EnumPropertyItem BufEdgeMode_items[] = {
2281                 {0, "BLEED_OUT",  0, "Bleed Out",     "Allow mask pixels to bleed along edges"},
2282                 {1, "KEEP_IN",  0, "Keep In",     "Restrict mask pixels from touching edges"},
2283                 {0, NULL, 0, NULL, NULL}
2284         };
2285
2286         static EnumPropertyItem InnerEdgeMode_items[] = {
2287                 {0, "ALL", 0, "All", "All pixels on inner mask edge are considered during mask calculation"},
2288                 {1, "ADJACENT_ONLY", 0, "Adjacent Only",
2289                     "Only inner mask pixels adjacent to outer mask pixels are considered during mask calculation"},
2290                 {0, NULL, 0, NULL, NULL}
2291         };
2292
2293         prop = RNA_def_property(srna, "inner_mode", PROP_ENUM, PROP_NONE);
2294         RNA_def_property_enum_sdna(prop, NULL, "custom2");
2295         RNA_def_property_enum_items(prop, InnerEdgeMode_items);
2296         RNA_def_property_ui_text(prop, "Inner Edge Mode", "");
2297         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2298
2299         prop = RNA_def_property(srna, "edge_mode", PROP_ENUM, PROP_NONE);
2300         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2301         RNA_def_property_enum_items(prop, BufEdgeMode_items);
2302         RNA_def_property_ui_text(prop, "Buffer Edge Mode", "");
2303         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2304 }
2305
2306 static void def_cmp_map_uv(StructRNA *srna)
2307 {
2308         PropertyRNA *prop;
2309
2310         prop = RNA_def_property(srna, "alpha", PROP_INT, PROP_FACTOR);
2311         RNA_def_property_int_sdna(prop, NULL, "custom1");
2312         RNA_def_property_range(prop, 0, 100);
2313         RNA_def_property_ui_text(prop, "Alpha", "");
2314         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2315 }
2316
2317 static void def_cmp_defocus(StructRNA *srna)
2318 {
2319         PropertyRNA *prop;
2320         
2321         static EnumPropertyItem bokeh_items[] = {
2322                 {8, "OCTAGON",  0, "Octagonal",  "8 sides"},
2323                 {7, "HEPTAGON", 0, "Heptagonal", "7 sides"},
2324                 {6, "HEXAGON",  0, "Hexagonal",  "6 sides"},
2325                 {5, "PENTAGON", 0, "Pentagonal", "5 sides"},
2326                 {4, "SQUARE",   0, "Square",     "4 sides"},
2327                 {3, "TRIANGLE", 0, "Triangular", "3 sides"},
2328                 {0, "CIRCLE",   0, "Circular",   ""},
2329                 {0, NULL, 0, NULL, NULL}};
2330         
2331         RNA_def_struct_sdna_from(srna, "NodeDefocus", "storage");
2332         
2333         prop = RNA_def_property(srna, "bokeh", PROP_ENUM, PROP_NONE);
2334         RNA_def_property_enum_sdna(prop, NULL, "bktype");
2335         RNA_def_property_enum_items(prop, bokeh_items);
2336         RNA_def_property_ui_text(prop, "Bokeh Type", "");
2337         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2338
2339         /* TODO: angle in degrees */
2340         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
2341         RNA_def_property_float_sdna(prop, NULL, "rotation");
2342         RNA_def_property_range(prop, 0.0f, DEG2RADF(90.0f));
2343         RNA_def_property_ui_text(prop, "Angle", "Bokeh shape rotation offset");
2344         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2345         
2346         prop = RNA_def_property(srna, "use_gamma_correction", PROP_BOOLEAN, PROP_NONE);
2347         RNA_def_property_boolean_sdna(prop, NULL, "gamco", 1);
2348         RNA_def_property_ui_text(prop, "Gamma Correction", "Enable gamma correction before and after main process");
2349         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2350
2351         /* TODO */
2352         prop = RNA_def_property(srna, "f_stop", PROP_FLOAT, PROP_NONE);
2353         RNA_def_property_float_sdna(prop, NULL, "fstop");
2354         RNA_def_property_range(prop, 0.0f, 128.0f);
2355         RNA_def_property_ui_text(prop, "fStop",
2356                                  "Amount of focal blur, 128=infinity=perfect focus, half the value doubles "
2357                                  "the blur radius");
2358         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2359         
2360         prop = RNA_def_property(srna, "blur_max", PROP_FLOAT, PROP_NONE);
2361         RNA_def_property_float_sdna(prop, NULL, "maxblur");
2362         RNA_def_property_range(prop, 0.0f, 10000.0f);
2363         RNA_def_property_ui_text(prop, "Max Blur", "Blur limit, maximum CoC radius, 0=no limit");
2364         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2365         
2366         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
2367         RNA_def_property_float_sdna(prop, NULL, "bthresh");
2368         RNA_def_property_range(prop, 0.0f, 100.0f);
2369         RNA_def_property_ui_text(prop, "Threshold",
2370                                  "CoC radius threshold, prevents background bleed on in-focus midground, 0=off");
2371         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2372         
2373         prop = RNA_def_property(srna, "use_preview", PROP_BOOLEAN, PROP_NONE);
2374         RNA_def_property_boolean_sdna(prop, NULL, "preview", 1);
2375         RNA_def_property_ui_text(prop, "Preview", "Enable sampling mode, useful for preview when using low samplecounts");
2376         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2377         
2378         prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
2379         RNA_def_property_int_sdna(prop, NULL, "samples");
2380         RNA_def_property_range(prop, 16, 256);
2381         RNA_def_property_ui_text(prop, "Samples", "Number of samples (16=grainy, higher=less noise)");
2382         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2383         
2384         prop = RNA_def_property(srna, "use_zbuffer", PROP_BOOLEAN, PROP_NONE);
2385         RNA_def_property_boolean_negative_sdna(prop, NULL, "no_zbuf", 1);
2386         RNA_def_property_ui_text(prop, "Use Z-Buffer",
2387                                  "Disable when using an image as input instead of actual z-buffer "
2388                                  "(auto enabled if node not image based, eg. time node)");
2389         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2390         
2391         prop = RNA_def_property(srna, "z_scale", PROP_FLOAT, PROP_NONE);
2392         RNA_def_property_float_sdna(prop, NULL, "scale");
2393         RNA_def_property_range(prop, 0.0f, 1000.0f);
2394         RNA_def_property_ui_text(prop, "Z-Scale",
2395                                  "Scale the Z input when not using a z-buffer, controls maximum blur designated "
2396                                  "by the color white or input value 1");
2397         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2398 }
2399
2400 static void def_cmp_invert(StructRNA *srna)
2401 {
2402         PropertyRNA *prop;
2403         
2404         prop = RNA_def_property(srna, "invert_rgb", PROP_BOOLEAN, PROP_NONE);
2405         RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_CHAN_RGB);
2406         RNA_def_property_ui_text(prop, "RGB", "");
2407         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2408         
2409         prop = RNA_def_property(srna, "invert_alpha", PROP_BOOLEAN, PROP_NONE);
2410         RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_CHAN_A);
2411         RNA_def_property_ui_text(prop, "Alpha", "");
2412         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2413 }
2414
2415 static void def_cmp_crop(StructRNA *srna)
2416 {
2417         PropertyRNA *prop;
2418         
2419         prop = RNA_def_property(srna, "use_crop_size", PROP_BOOLEAN, PROP_NONE);
2420         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 1);
2421         RNA_def_property_ui_text(prop, "Crop Image Size", "Whether to crop the size of the input image");
2422         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2423
2424         prop = RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
2425         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
2426         RNA_def_property_ui_text(prop, "Relative", "Use relative values to crop image");
2427         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2428
2429         RNA_def_struct_sdna_from(srna, "NodeTwoXYs", "storage");
2430
2431         prop = RNA_def_property(srna, "min_x", PROP_INT, PROP_NONE);
2432         RNA_def_property_int_sdna(prop, NULL, "x1");
2433         RNA_def_property_range(prop, 0, 10000);
2434         RNA_def_property_ui_text(prop, "X1", "");
2435         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2436         
2437         prop = RNA_def_property(srna, "max_x", PROP_INT, PROP_NONE);
2438         RNA_def_property_int_sdna(prop, NULL, "x2");
2439         RNA_def_property_range(prop, 0, 10000);
2440         RNA_def_property_ui_text(prop, "X2", "");
2441         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2442         
2443         prop = RNA_def_property(srna, "min_y", PROP_INT, PROP_NONE);
2444         RNA_def_property_int_sdna(prop, NULL, "y1");
2445         RNA_def_property_range(prop, 0, 10000);
2446         RNA_def_property_ui_text(prop, "Y1", "");
2447         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2448         
2449         prop = RNA_def_property(srna, "max_y", PROP_INT, PROP_NONE);
2450         RNA_def_property_int_sdna(prop, NULL, "y2");
2451         RNA_def_property_range(prop, 0, 10000);
2452         RNA_def_property_ui_text(prop, "Y2", "");
2453         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2454
2455         prop = RNA_def_property(srna, "rel_min_x", PROP_FLOAT, PROP_NONE);
2456         RNA_def_property_float_sdna(prop, NULL, "fac_x1");
2457         RNA_def_property_range(prop, 0.0, 1.0);
2458         RNA_def_property_ui_text(prop, "X1", "");
2459         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2460
2461         prop = RNA_def_property(srna, "rel_max_x", PROP_FLOAT, PROP_NONE);
2462         RNA_def_property_float_sdna(prop, NULL, "fac_x2");
2463         RNA_def_property_range(prop, 0.0, 1.0);
2464         RNA_def_property_ui_text(prop, "X2", "");
2465         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2466
2467         prop = RNA_def_property(srna, "rel_min_y", PROP_FLOAT, PROP_NONE);
2468         RNA_def_property_float_sdna(prop, NULL, "fac_y1");
2469         RNA_def_property_range(prop, 0.0, 1.0);
2470         RNA_def_property_ui_text(prop, "Y1", "");
2471         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2472
2473         prop = RNA_def_property(srna, "rel_max_y", PROP_FLOAT, PROP_NONE);
2474         RNA_def_property_float_sdna(prop, NULL, "fac_y2");
2475         RNA_def_property_range(prop, 0.0, 1.0);
2476         RNA_def_property_ui_text(prop, "Y2", "");
2477         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2478 }
2479
2480 static void def_cmp_dblur(StructRNA *srna)
2481 {
2482         PropertyRNA *prop;
2483         
2484         RNA_def_struct_sdna_from(srna, "NodeDBlurData", "storage");
2485         
2486         prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
2487         RNA_def_property_int_sdna(prop, NULL, "iter");
2488         RNA_def_property_range(prop, 1, 32);
2489         RNA_def_property_ui_text(prop, "Iterations", "");
2490         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2491         
2492         prop = RNA_def_property(srna, "use_wrap", PROP_BOOLEAN, PROP_NONE);
2493         RNA_def_property_boolean_sdna(prop, NULL, "wrap", 1);
2494         RNA_def_property_ui_text(prop, "Wrap", "");
2495         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2496         
2497         prop = RNA_def_property(srna, "center_x", PROP_FLOAT, PROP_NONE);
2498         RNA_def_property_float_sdna(prop, NULL, "center_x");
2499         RNA_def_property_range(prop, 0.0f, 1.0f);
2500         RNA_def_property_ui_text(prop, "Center X", "");
2501         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2502         
2503         prop = RNA_def_property(srna, "center_y", PROP_FLOAT, PROP_NONE);
2504         RNA_def_property_float_sdna(prop, NULL, "center_y");
2505         RNA_def_property_range(prop, 0.0f, 1.0f);
2506         RNA_def_property_ui_text(prop, "Center Y", "");
2507         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2508         
2509         prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
2510         RNA_def_property_float_sdna(prop, NULL, "distance");
2511         RNA_def_property_range(prop, -1.0f, 1.0f);
2512         RNA_def_property_ui_text(prop, "Distance", "");
2513         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2514         
2515         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
2516         RNA_def_property_float_sdna(prop, NULL, "angle");
2517         RNA_def_property_range(prop, 0.0f, DEG2RADF(360.0f));
2518         RNA_def_property_ui_text(prop, "Angle", "");
2519         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2520         
2521         prop = RNA_def_property(srna, "spin", PROP_FLOAT, PROP_ANGLE);
2522         RNA_def_property_float_sdna(prop, NULL, "spin");
2523         RNA_def_property_range(prop, DEG2RADF(-360.0f), DEG2RADF(360.0f));
2524         RNA_def_property_ui_text(prop, "Spin", "");
2525         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2526         
2527         prop = RNA_def_property(srna, "zoom", PROP_FLOAT, PROP_NONE);
2528         RNA_def_property_float_sdna(prop, NULL, "zoom");
2529         RNA_def_property_range(prop, 0.0f, 100.0f);
2530         RNA_def_property_ui_text(prop, "Zoom", "");
2531         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2532 }
2533
2534 static void def_cmp_bilateral_blur(StructRNA *srna)
2535 {
2536         PropertyRNA *prop;
2537         
2538         RNA_def_struct_sdna_from(srna, "NodeBilateralBlurData", "storage");
2539         
2540         prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
2541         RNA_def_property_int_sdna(prop, NULL, "iter");
2542         RNA_def_property_range(prop, 1, 128);
2543         RNA_def_property_ui_text(prop, "Iterations", "");
2544         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2545         
2546         prop = RNA_def_property(srna, "sigma_color", PROP_FLOAT, PROP_NONE);
2547         RNA_def_property_float_sdna(prop, NULL, "sigma_color");
2548         RNA_def_property_range(prop, 0.01f, 3.0f);
2549         RNA_def_property_ui_text(prop, "Color Sigma", "");
2550         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2551         
2552         prop = RNA_def_property(srna, "sigma_space", PROP_FLOAT, PROP_NONE);
2553         RNA_def_property_float_sdna(prop, NULL, "sigma_space");
2554         RNA_def_property_range(prop, 0.01f, 30.0f);
2555         RNA_def_property_ui_text(prop, "Space Sigma", "");
2556         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2557 }
2558
2559 static void def_cmp_premul_key(StructRNA *srna)
2560 {
2561         PropertyRNA *prop;
2562         
2563         static EnumPropertyItem type_items[] = {
2564                 {0, "KEY_TO_PREMUL", 0, "Key to Premul", ""},
2565                 {1, "PREMUL_TO_KEY", 0, "Premul to Key", ""},
2566                 {0, NULL, 0, NULL, NULL}};
2567         
2568         prop = RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
2569         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2570         RNA_def_property_enum_items(prop, type_items);
2571         RNA_def_property_ui_text(prop, "Mapping", "Conversion between premultiplied alpha and key alpha");
2572         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2573         
2574 }
2575
2576 static void def_cmp_glare(StructRNA *srna)
2577 {
2578         PropertyRNA *prop;
2579         
2580         static EnumPropertyItem type_items[] = {
2581                 {3, "GHOSTS",      0, "Ghosts",      ""},
2582                 {2, "STREAKS",     0, "Streaks",     ""},
2583                 {1, "FOG_GLOW",    0, "Fog Glow",    ""},
2584                 {0, "SIMPLE_STAR", 0, "Simple Star", ""},
2585                 {0, NULL, 0, NULL, NULL}};
2586         
2587         static EnumPropertyItem quality_items[] = {
2588                 {0, "HIGH",   0, "High",   ""},
2589                 {1, "MEDIUM", 0, "Medium", ""},
2590                 {2, "LOW",    0, "Low",    ""},
2591                 {0, NULL, 0, NULL, NULL}};
2592         
2593         RNA_def_struct_sdna_from(srna, "NodeGlare", "storage");
2594         
2595         prop = RNA_def_property(srna, "glare_type", PROP_ENUM, PROP_NONE);
2596         RNA_def_property_enum_sdna(prop, NULL, "type");
2597         RNA_def_property_enum_items(prop, type_items);
2598         RNA_def_property_ui_text(prop, "Glare Type", "");
2599         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2600         
2601         prop = RNA_def_property(srna, "quality", PROP_ENUM, PROP_NONE);
2602         RNA_def_property_enum_sdna(prop, NULL, "quality");
2603         RNA_def_property_enum_items(prop, quality_items);
2604         RNA_def_property_ui_text(prop, "Quality",
2605                                  "If not set to high quality, the effect will be applied to a low-res copy "
2606                                  "of the source image");
2607         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2608         
2609         prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
2610         RNA_def_property_int_sdna(prop, NULL, "iter");
2611         RNA_def_property_range(prop, 2, 5);
2612         RNA_def_property_ui_text(prop, "Iterations", "");
2613         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2614         
2615         prop = RNA_def_property(srna, "color_modulation", PROP_FLOAT, PROP_NONE);
2616         RNA_def_property_float_sdna(prop, NULL, "colmod");
2617         RNA_def_property_range(prop, 0.0f, 1.0f);
2618         RNA_def_property_ui_text(prop, "Color Modulation",
2619                                  "Amount of Color Modulation, modulates colors of streaks and ghosts for "
2620                                  "a spectral dispersion effect");
2621         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2622         
2623         prop = RNA_def_property(srna, "mix", PROP_FLOAT, PROP_NONE);
2624         RNA_def_property_float_sdna(prop, NULL, "mix");
2625         RNA_def_property_range(prop, -1.0f, 1.0f);
2626         RNA_def_property_ui_text(prop, "Mix",
2627                                  "-1 is original image only, 0 is exact 50/50 mix, 1 is processed image only");
2628         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2629         
2630         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
2631         RNA_def_property_float_sdna(prop, NULL, "threshold");
2632         RNA_def_property_range(prop, 0.0f, 1000.0f);
2633         RNA_def_property_ui_text(prop, "Threshold",
2634                                  "The glare filter will only be applied to pixels brighter than this value");
2635         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2636         
2637         prop = RNA_def_property(srna, "streaks", PROP_INT, PROP_NONE);
2638         RNA_def_property_int_sdna(prop, NULL, "angle");
2639         RNA_def_property_range(prop, 2, 16);
2640         RNA_def_property_ui_text(prop, "Streaks", "Total number of streaks");
2641         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2642         
2643         prop = RNA_def_property(srna, "angle_offset", PROP_FLOAT, PROP_ANGLE);
2644         RNA_def_property_float_sdna(prop, NULL, "angle_ofs");
2645         RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
2646         RNA_def_property_ui_text(prop, "Angle Offset", "Streak angle offset");
2647         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2648         
2649         prop = RNA_def_property(srna, "fade", PROP_FLOAT, PROP_NONE);
2650         RNA_def_property_float_sdna(prop, NULL, "fade");
2651         RNA_def_property_range(prop, 0.75f, 1.0f);
2652         RNA_def_property_ui_text(prop, "Fade", "Streak fade-out factor");
2653         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2654         
2655         prop = RNA_def_property(srna, "use_rotate_45", PROP_BOOLEAN, PROP_NONE);
2656         RNA_def_property_boolean_sdna(prop, NULL, "angle", 0);
2657         RNA_def_property_ui_text(prop, "Rotate 45", "Simple star filter: add 45 degree rotation offset");
2658         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2659         
2660         prop = RNA_def_property(srna, "size", PROP_INT, PROP_NONE);
2661         RNA_def_property_int_sdna(prop, NULL, "size");
2662         RNA_def_property_range(prop, 6, 9);
2663         RNA_def_property_ui_text(prop, "Size",
2664                                  "Glow/glare size (not actual size; relative to initial size of bright area of pixels)");
2665         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2666         
2667         /* TODO */
2668 }
2669
2670 static void def_cmp_tonemap(StructRNA *srna)
2671 {
2672         PropertyRNA *prop;
2673         
2674         static EnumPropertyItem type_items[] = {
2675                 {1, "RD_PHOTORECEPTOR", 0, "R/D Photoreceptor", ""},
2676                 {0, "RH_SIMPLE",        0, "Rh Simple",         ""},
2677                 {0, NULL, 0, NULL, NULL}};
2678         
2679         RNA_def_struct_sdna_from(srna, "NodeTonemap", "storage");
2680         
2681         prop = RNA_def_property(srna, "tonemap_type", PROP_ENUM, PROP_NONE);
2682         RNA_def_property_enum_sdna(prop, NULL, "type");
2683         RNA_def_property_enum_items(prop, type_items);
2684         RNA_def_property_ui_text(prop, "Tonemap Type", "");
2685         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2686         
2687         prop = RNA_def_property(srna, "key", PROP_FLOAT, PROP_NONE);
2688         RNA_def_property_float_sdna(prop, NULL, "key");
2689         RNA_def_property_range(prop, 0.0f, 1.0f);
2690         RNA_def_property_ui_text(prop, "Key", "The value the average luminance is mapped to");
2691         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2692         
2693         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
2694         RNA_def_property_float_sdna(prop, NULL, "offset");
2695         RNA_def_property_range(prop, 0.001f, 10.0f);
2696         RNA_def_property_ui_text(prop, "Offset",
2697                                  "Normally always 1, but can be used as an extra control to alter the brightness curve");
2698         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2699         
2700         prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_NONE);
2701         RNA_def_property_float_sdna(prop, NULL, "gamma");
2702         RNA_def_property_range(prop, 0.001f, 3.0f);
2703         RNA_def_property_ui_text(prop, "Gamma", "If not used, set to 1");
2704         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2705         
2706         prop = RNA_def_property(srna, "intensity", PROP_FLOAT, PROP_NONE);
2707         RNA_def_property_float_sdna(prop, NULL, "f");
2708         RNA_def_property_range(prop, -8.0f, 8.0f);
2709         RNA_def_property_ui_text(prop, "Intensity", "If less than zero, darkens image; otherwise, makes it brighter");
2710         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2711         
2712         prop = RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_NONE);
2713         RNA_def_property_float_sdna(prop, NULL, "m");
2714         RNA_def_property_range(prop, 0.0f, 1.0f);
2715         RNA_def_property_ui_text(prop, "Contrast", "Set to 0 to use estimate from input image");
2716         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2717         
2718         prop = RNA_def_property(srna, "adaptation", PROP_FLOAT, PROP_NONE);
2719         RNA_def_property_float_sdna(prop, NULL, "a");
2720         RNA_def_property_range(prop, 0.0f, 1.0f);
2721         RNA_def_property_ui_text(prop, "Adaptation", "If 0, global; if 1, based on pixel intensity");
2722         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2723         
2724         prop = RNA_def_property(srna, "correction", PROP_FLOAT, PROP_NONE);
2725         RNA_def_property_float_sdna(prop, NULL, "c");
2726         RNA_def_property_range(prop, 0.0f, 1.0f);
2727         RNA_def_property_ui_text(prop, "Color Correction", "If 0, same for all channels; if 1, each independent");
2728         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2729 }
2730
2731 static void def_cmp_lensdist(StructRNA *srna)
2732 {
2733         PropertyRNA *prop;
2734         
2735         RNA_def_struct_sdna_from(srna, "NodeLensDist", "storage");
2736         
2737         prop = RNA_def_property(srna, "use_projector", PROP_BOOLEAN, PROP_NONE);
2738         RNA_def_property_boolean_sdna(prop, NULL, "proj", 1);
2739         RNA_def_property_ui_text(prop, "Projector",
2740                                  "Enable/disable projector mode (the effect is applied in horizontal direction only)");
2741         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2742         
2743         prop = RNA_def_property(srna, "use_jitter", PROP_BOOLEAN, PROP_NONE);
2744         RNA_def_property_boolean_sdna(prop, NULL, "jit", 1);
2745         RNA_def_property_ui_text(prop, "Jitter", "Enable/disable jittering (faster, but also noisier)");
2746         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2747         
2748         prop = RNA_def_property(srna, "use_fit", PROP_BOOLEAN, PROP_NONE);
2749         RNA_def_property_boolean_sdna(prop, NULL, "fit", 1);
2750         RNA_def_property_ui_text(prop, "Fit",
2751                                  "For positive distortion factor only: scale image such that black areas are not visible");
2752         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2753 }
2754
2755 static void def_cmp_colorbalance(StructRNA *srna)
2756 {
2757         PropertyRNA *prop;
2758         static float default_1[3] = {1.f, 1.f, 1.f};
2759         
2760         static EnumPropertyItem type_items[] = {
2761                 {0, "LIFT_GAMMA_GAIN", 0, "Lift/Gamma/Gain", ""},
2762                 {1, "OFFSET_POWER_SLOPE", 0, "Offset/Power/Slope (ASC-CDL)", "ASC-CDL standard color correction"},
2763                 {0, NULL, 0, NULL, NULL}};
2764         
2765         prop = RNA_def_property(srna, "correction_method", PROP_ENUM, PROP_NONE);
2766         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2767         RNA_def_property_enum_items(prop, type_items);
2768         RNA_def_property_ui_text(prop, "Correction Formula", "");
2769         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2770         
2771         RNA_def_struct_sdna_from(srna, "NodeColorBalance", "storage");
2772         
2773         prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_COLOR_GAMMA);
2774         RNA_def_property_float_sdna(prop, NULL, "lift");
2775         RNA_def_property_array(prop, 3);
2776         RNA_def_property_float_array_default(prop, default_1);
2777         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
2778         RNA_def_property_ui_text(prop, "Lift", "Correction for Shadows");
2779         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2780         
2781         prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_COLOR_GAMMA);
2782         RNA_def_property_float_sdna(prop, NULL, "gamma");
2783         RNA_def_property_array(prop, 3);
2784         RNA_def_property_float_array_default(prop, default_1);
2785         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
2786         RNA_def_property_ui_text(prop, "Gamma", "Correction for Midtones");
2787         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2788         
2789         prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_COLOR_GAMMA);
2790         RNA_def_property_float_sdna(prop, NULL, "gain");
2791         RNA_def_property_array(prop, 3);
2792         RNA_def_property_float_array_default(prop, default_1);
2793         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
2794         RNA_def_property_ui_text(prop, "Gain", "Correction for Highlights");
2795         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2796         
2797         
2798         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_COLOR_GAMMA);
2799         RNA_def_property_float_sdna(prop, NULL, "lift");
2800         RNA_def_property_array(prop, 3);
2801         RNA_def_property_ui_range(prop, 0, 1, 0.1, 3);
2802         RNA_def_property_ui_text(prop, "Offset", "Correction for Shadows");
2803         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2804         
2805         prop = RNA_def_property(srna, "power", PROP_FLOAT, PROP_COLOR_GAMMA);
2806         RNA_def_property_float_sdna(prop, NULL, "gamma");
2807         RNA_def_property_array(prop, 3);
2808         RNA_def_property_float_array_default(prop, default_1);
2809         RNA_def_property_range(prop, 0.f, FLT_MAX);
2810         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
2811         RNA_def_property_ui_text(prop, "Power", "Correction for Midtones");
2812         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2813         
2814         prop = RNA_def_property(srna, "slope", PROP_FLOAT, PROP_COLOR_GAMMA);
2815         RNA_def_property_float_sdna(prop, NULL, "gain");
2816         RNA_def_property_array(prop, 3);
2817         RNA_def_property_float_array_default(prop, default_1);
2818         RNA_def_property_range(prop, 0.f, FLT_MAX);
2819         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
2820         RNA_def_property_ui_text(prop, "Slope", "Correction for Highlights");
2821         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2822 }
2823
2824 static void def_cmp_huecorrect(StructRNA *srna)
2825 {
2826         PropertyRNA *prop;
2827         
2828         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
2829         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2830         RNA_def_property_struct_type(prop, "CurveMapping");
2831         RNA_def_property_ui_text(prop, "Mapping", "");
2832         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2833 }
2834
2835 static void def_cmp_zcombine(StructRNA *srna)
2836 {
2837         PropertyRNA *prop;
2838         
2839         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
2840         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 0);
2841         RNA_def_property_ui_text(prop, "Use Alpha", "Take Alpha channel into account when doing the Z operation");
2842         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2843 }
2844
2845 static void def_cmp_ycc(StructRNA *srna)
2846 {
2847         PropertyRNA *prop;
2848         
2849         prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
2850         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2851         RNA_def_property_enum_items(prop, node_ycc_items);
2852         RNA_def_property_ui_text(prop, "Mode", "");
2853         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2854 }
2855
2856 static void def_cmp_movieclip(StructRNA *srna)
2857 {
2858         PropertyRNA *prop;
2859
2860         prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
2861         RNA_def_property_pointer_sdna(prop, NULL, "id");
2862         RNA_def_property_struct_type(prop, "MovieClip");
2863         RNA_def_property_flag(prop, PROP_EDITABLE);
2864         RNA_def_property_ui_text(prop, "Movie Clip", "");
2865         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2866
2867         RNA_def_struct_sdna_from(srna, "MovieClipUser", "storage");
2868 }
2869
2870 static void def_cmp_stabilize2d(StructRNA *srna)
2871 {
2872         PropertyRNA *prop;
2873
2874         static EnumPropertyItem filter_type_items[] = {
2875                 {0, "NEAREST",   0, "Nearest",   ""},
2876                 {1, "BILINEAR",   0, "Bilinear",   ""},
2877                 {2, "BICUBIC", 0, "Bicubic", ""},
2878                 {0, NULL, 0, NULL, NULL}};
2879
2880         prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
2881         RNA_def_property_pointer_sdna(prop, NULL, "id");
2882         RNA_def_property_struct_type(prop, "MovieClip");
2883         RNA_def_property_flag(prop, PROP_EDITABLE);
2884         RNA_def_property_ui_text(prop, "Movie Clip", "");
2885         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2886
2887         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
2888         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2889         RNA_def_property_enum_items(prop, filter_type_items);
2890         RNA_def_property_ui_text(prop, "Filter", "Method to use to filter stabilization");
2891         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2892 }
2893
2894 static void def_cmp_moviedistortion(StructRNA *srna)
2895 {
2896         PropertyRNA *prop;
2897
2898         static EnumPropertyItem distortion_type_items[] = {
2899                 {0, "UNDISTORT",   0, "Undistort",   ""},
2900                 {1, "DISTORT", 0, "Distort", ""},
2901                 {0, NULL, 0, NULL, NULL}};
2902
2903         prop = RNA_def_property(srna, "clip", PROP_POINTER, PROP_NONE);
2904         RNA_def_property_pointer_sdna(prop, NULL, "id");
2905         RNA_def_property_struct_type(prop, "MovieClip");
2906         RNA_def_property_flag(prop, PROP_EDITABLE);
2907         RNA_def_property_ui_text(prop, "Movie Clip", "");
2908         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2909
2910         prop = RNA_def_property(srna, "distortion_type", PROP_ENUM, PROP_NONE);
2911         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2912         RNA_def_property_enum_items(prop, distortion_type_items);
2913         RNA_def_property_ui_text(prop, "Distortion", "Distortion to use to filter image");
2914         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2915 }
2916
2917 static void def_cmp_mask(StructRNA *srna)
2918 {
2919         PropertyRNA *prop;
2920
2921         prop = RNA_def_property(srna, "mask", PROP_POINTER, PROP_NONE);
2922         RNA_def_property_pointer_sdna(prop, NULL, "id");
2923         RNA_def_property_struct_type(prop, "Mask");
2924         RNA_def_property_flag(prop, PROP_EDITABLE);
2925         RNA_def_property_ui_text(prop, "Mask", "");
2926         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2927 }
2928
2929 static void dev_cmd_transform(StructRNA *srna)
2930 {
2931         PropertyRNA *prop;
2932
2933         static EnumPropertyItem filter_type_items[] = {
2934                 {0, "NEAREST",   0, "Nearest",   ""},
2935                 {1, "BILINEAR",   0, "Bilinear",   ""},
2936                 {2, "BICUBIC", 0, "Bicubic", ""},
2937                 {0, NULL, 0, NULL, NULL}};
2938
2939         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
2940         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2941         RNA_def_property_enum_items(prop, filter_type_items);
2942         RNA_def_property_ui_text(prop, "Filter", "Method to use to filter transform");
2943         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2944 }
2945
2946
2947 /* -- Texture Nodes --------------------------------------------------------- */
2948
2949 static void def_tex_output(StructRNA *srna)
2950 {
2951         PropertyRNA *prop;
2952
2953         RNA_def_struct_sdna_from(srna, "TexNodeOutput", "storage");
2954         
2955         prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_NONE);
2956         RNA_def_property_string_sdna(prop, NULL, "name");
2957         RNA_def_property_ui_text(prop, "Output Name", "");
2958         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2959 }
2960
2961 static void def_tex_image(StructRNA *srna)
2962 {
2963         PropertyRNA *prop;
2964
2965         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
2966         RNA_def_property_pointer_sdna(prop, NULL, "id");
2967         RNA_def_property_struct_type(prop, "Image");
2968         RNA_def_property_flag(prop, PROP_EDITABLE);
2969         RNA_def_property_ui_text(prop, "Image", "");
2970         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2971         
2972         /* is this supposed to be exposed? not sure.. */
2973 #if 0
2974         prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
2975         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2976         RNA_def_property_struct_type(prop, "ImageUser");
2977         RNA_def_property_ui_text(prop, "Settings", "");
2978         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2979 #endif
2980 }
2981
2982 static void def_tex_bricks(StructRNA *srna)
2983 {
2984         PropertyRNA *prop;
2985
2986         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
2987         RNA_def_property_float_sdna(prop, NULL, "custom3");
2988         RNA_def_property_range(prop, 0.0f, 1.0f);
2989         RNA_def_property_ui_text(prop, "Offset Amount", "");
2990         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2991         
2992         prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE);
2993         RNA_def_property_int_sdna(prop, NULL, "custom1");
2994         RNA_def_property_range(prop, 2, 99);
2995         RNA_def_property_ui_text(prop, "Offset Frequency", "Offset every N rows");
2996         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
2997         
2998         prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE);
2999         RNA_def_property_float_sdna(prop, NULL, "custom4");
3000         RNA_def_property_range(prop, 0.0f, 99.0f);
3001         RNA_def_property_ui_text(prop, "Squash Amount", "");
3002         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
3003         
3004         prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE);
3005         RNA_def_property_int_sdna(prop, NULL, "custom2");
3006         RNA_def_property_range(prop, 2, 99);
3007         RNA_def_property_ui_text(prop, "Squash Frequency", "Squash every N rows");
3008         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
3009 }
3010
3011 /* -------------------------------------------------------------------------- */
3012
3013 static EnumPropertyItem shader_node_type_items[MaxNodes];
3014 static void rna_def_shader_node(BlenderRNA *brna)
3015 {
3016         StructRNA *srna;
3017         PropertyRNA *prop;
3018         
3019         alloc_node_type_items(shader_node_type_items, Category_ShaderNode);
3020
3021         srna = RNA_def_struct(brna, "ShaderNode", "Node");
3022         RNA_def_struct_ui_text(srna, "Shader Node", "Material shader node");
3023         RNA_def_struct_sdna(srna, "bNode");
3024
3025         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
3026         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3027         RNA_def_property_enum_items(prop, shader_node_type_items);
3028         RNA_def_property_ui_text(prop, "Type", "");
3029 }
3030
3031 static EnumPropertyItem compositor_node_type_items[MaxNodes];
3032 static void rna_def_compositor_node(BlenderRNA *brna)
3033 {
3034         StructRNA *srna;
3035         PropertyRNA *prop;
3036         
3037         alloc_node_type_items(compositor_node_type_items, Category_CompositorNode);
3038         
3039         srna = RNA_def_struct(brna, "CompositorNode", "Node");
3040         RNA_def_struct_ui_text(srna, "Compositor Node", "");
3041         RNA_def_struct_sdna(srna, "bNode");
3042
3043         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
3044         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3045         RNA_def_property_enum_items(prop, compositor_node_type_items);
3046         RNA_def_property_ui_text(prop, "Type", "");
3047 }
3048
3049 static EnumPropertyItem texture_node_type_items[MaxNodes];
3050 static void rna_def_texture_node(BlenderRNA *brna)
3051 {
3052         StructRNA *srna;
3053         PropertyRNA *prop;
3054         
3055         alloc_node_type_items(texture_node_type_items, Category_TextureNode);
3056         
3057         srna = RNA_def_struct(brna, "TextureNode", "Node");
3058         RNA_def_struct_ui_text(srna, "Texture Node", "");
3059         RNA_def_struct_sdna(srna, "bNode");
3060
3061         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
3062         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3063         RNA_def_property_enum_items(prop, texture_node_type_items);
3064         RNA_def_property_ui_text(prop, "Type", "");
3065 }
3066
3067 /* -------------------------------------------------------------------------- */
3068
3069 static void rna_def_nodetree_link_api(BlenderRNA *brna, PropertyRNA *cprop)
3070 {
3071         StructRNA *srna;
3072         PropertyRNA *parm;
3073         FunctionRNA *func;
3074
3075         RNA_def_property_srna(cprop, "NodeLinks");
3076         srna = RNA_def_struct(brna, "NodeLinks", NULL);
3077         RNA_def_struct_sdna(srna, "bNodeTree");
3078         RNA_def_struct_ui_text(srna, "Node Links", "Collection of Node Links");
3079
3080         func = RNA_def_function(srna, "new", "rna_NodeTree_link_new");
3081         RNA_def_function_ui_description(func, "Add a node link to this node tree");
3082         RNA_def_function_flag(func, FUNC_USE_REPORTS);
3083         parm = RNA_def_pointer(func, "input", "NodeSocket", "", "The input socket");
3084         RNA_def_property_flag(parm, PROP_REQUIRED);
3085         parm = RNA_def_pointer(func, "output", "NodeSocket", "", "The output socket");
3086         RNA_def_property_flag(parm, PROP_REQUIRED);
3087         /* return */
3088         parm = RNA_def_pointer(func, "link", "NodeLink", "", "New node link");
3089         RNA_def_function_return(func, parm);
3090
3091         func = RNA_def_function(srna, "remove", "rna_NodeTree_link_remove");
3092         RNA_def_function_ui_description(func, "remove a node link from the node tree");
3093         RNA_def_function_flag(func, FUNC_USE_REPORTS);
3094         parm = RNA_def_pointer(func, "link", "NodeLink", "", "The node link to remove");
3095         RNA_def_property_flag(parm, PROP_REQUIRED);
3096
3097         func = RNA_def_function(srna, "clear", "rna_NodeTree_link_clear");
3098         RNA_def_function_ui_description(func, "remove all node links from the node tree");
3099 }
3100
3101 static void rna_def_composite_nodetree_api(BlenderRNA *brna, PropertyRNA *cprop)
3102 {
3103         StructRNA *srna;
3104         PropertyRNA *parm;
3105         FunctionRNA *func;
3106
3107         RNA_def_property_srna(cprop, "CompositorNodes");
3108         srna = RNA_def_struct(brna, "CompositorNodes", NULL);
3109         RNA_def_struct_sdna(srna, "bNodeTree");
3110         RNA_def_struct_ui_text(srna, "Compositor Nodes", "Collection of Compositor Nodes");
3111
3112         func = RNA_def_function(srna, "new", "rna_NodeTree_node_composite_new");
3113         RNA_def_function_ui_description(func, "Add a node to this node tree");
3114         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
3115         parm = RNA_def_enum(func, "type", compositor_node_type_items, 0, "Type", "Type of node to add");
3116         RNA_def_property_flag(parm, PROP_REQUIRED);
3117         RNA_def_pointer(func, "group", "NodeTree", "", "The group tree");
3118         /* return value */
3119         parm = RNA_def_pointer(func, "node", "Node", "", "New node");
3120         RNA_def_function_return(func, parm);
3121
3122         func = RNA_def_function(srna, "remove", "rna_NodeTree_node_remove");
3123         RNA_def_function_ui_description(func, "Remove a node from this node tree");
3124         RNA_def_function_flag(func, FUNC_USE_REPORTS);
3125         parm = RNA_def_pointer(func, "node", "Node", "", "The node to remove");
3126         RNA_def_property_flag(parm, PROP_REQUIRED);
3127
3128         func = RNA_def_function(srna, "clear", "rna_NodeTree_node_clear");
3129         RNA_def_function_ui_description(func, "Remove all nodes from this node tree");
3130 }
3131
3132 static void rna_def_shader_nodetree_api(BlenderRNA *brna, PropertyRNA *cprop)
3133 {
3134         StructRNA *srna;
3135         PropertyRNA *parm;
3136         FunctionRNA *func;
3137
3138         RNA_def_property_srna(cprop, "ShaderNodes");
3139         srna = RNA_def_struct(brna, "ShaderNodes", NULL);
3140         RNA_def_struct_sdna(srna, "bNodeTree");
3141         RNA_def_struct_ui_text(srna, "Shader Nodes", "Collection of Shader Nodes");
3142
3143         func = RNA_def_function(srna, "new", "rna_NodeTree_node_new");
3144         RNA_def_function_ui_description(func, "Add a node to this node tree");
3145         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
3146         parm = RNA_def_enum(func, "type", shader_node_type_items, 0, "Type", "Type of node to add");
3147         RNA_def_property_flag(parm, PROP_REQUIRED);
3148         RNA_def_pointer(func, "group", "NodeTree", "", "The group tree");
3149         /* return value */
3150         parm = RNA_def_pointer(func, "node", "Node", "", "New node");
3151         RNA_def_function_return(func, parm);
3152
3153         func = RNA_def_function(srna, "remove", "rna_NodeTree_node_remove");
3154         RNA_def_function_ui_description(func, "Remove a node from this node tree");
3155         RNA_def_function_flag(func, FUNC_USE_REPORTS);
3156         parm = RNA_def_pointer(func, "node", "Node", "", "The node to remove");
3157         RNA_def_property_flag(parm, PROP_REQUIRED);
3158
3159         func = RNA_def_function(srna, "clear", "rna_NodeTree_node_clear");
3160         RNA_def_function_ui_description(func, "Remove all nodes from this node tree");
3161 }
3162
3163 static void rna_def_texture_nodetree_api(BlenderRNA *brna, PropertyRNA *cprop)
3164 {
3165         StructRNA *srna;
3166         PropertyRNA *parm;
3167         FunctionRNA *func;
3168
3169         RNA_def_property_srna(cprop, "TextureNodes");
3170         srna = RNA_def_struct(brna, "TextureNodes", NULL);
3171         RNA_def_struct_sdna(srna, "bNodeTree");
3172         RNA_def_struct_ui_text(srna, "Texture Nodes", "Collection of Texture Nodes");
3173
3174         func = RNA_def_function(srna, "new", "rna_NodeTree_node_texture_new");
3175         RNA_def_function_ui_description(func, "Add a node to this node tree");
3176         RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
3177         parm = RNA_def_enum(func, "type", texture_node_type_items, 0, "Type", "Type of node to add");
3178         RNA_def_property_flag(parm, PROP_REQUIRED);
3179         RNA_def_pointer(func, "group", "NodeTree", "", "The group tree");
3180         /* return value */
3181         parm = RNA_def_pointer(func, "node", "Node", "", "New node");
3182         RNA_def_function_return(func, parm);
3183
3184         func = RNA_def_function(srna, "remove", "rna_NodeTree_node_remove");
3185         RNA_def_function_ui_description(func, "Remove a node from this node tree");
3186         RNA_def_function_flag(func, FUNC_USE_REPORTS);
3187         parm = RNA_def_pointer(func, "node", "Node", "", "The node to remove");
3188         RNA_def_property_flag(parm, PROP_REQUIRED);
3189
3190         func = RNA_def_function(srna, "clear", "rna_NodeTree_node_clear");
3191         RNA_def_function_ui_description(func, "Remove all nodes from this node tree");
3192 }
3193
3194 static void rna_def_node_socket(BlenderRNA *brna)
3195 {
3196         StructRNA *srna;
3197         PropertyRNA *prop;
3198
3199         srna = RNA_def_struct(brna, "NodeSocket", NULL);
3200         RNA_def_struct_ui_text(srna, "Node Socket", "Input or output socket of a node");
3201         RNA_def_struct_sdna(srna, "bNodeSocket");
3202         RNA_def_struct_refine_func(srna, "rna_NodeSocket_refine");
3203         RNA_def_struct_ui_icon(srna, ICON_PLUG);
3204         RNA_def_struct_path_func(srna, "rna_NodeSocket_path");
3205
3206         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
3207         RNA_def_property_enum_sdna(prop, NULL, "type");
3208         RNA_def_property_enum_items(prop, node_socket_type_items);
3209         RNA_def_property_enum_default(prop, 0);
3210         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3211         RNA_def_property_ui_text(prop, "Type", "Node Socket type");
3212
3213         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
3214         /* XXX must be editable for group sockets. if necessary use a special rna definition for these */
3215 /*      RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
3216         RNA_def_property_ui_text(prop, "Name", "Socket name");
3217         RNA_def_struct_name_property(srna, prop);
3218         RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroupSocket_update");
3219
3220         prop = RNA_def_property(srna, "group_socket", PROP_POINTER, PROP_NONE);
3221         RNA_def_property_pointer_sdna(prop, NULL, "groupsock");
3222         RNA_def_property_struct_type(prop, "NodeSocket");
3223         RNA_def_property_ui_text(prop, "Group Socket",
3224                                  "For group nodes, the group input or output socket this corresponds to");
3225
3226         prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
3227         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SOCK_COLLAPSED);
3228         RNA_def_property_ui_text(prop, "Expanded", "Socket links are expanded in the user interface");
3229         RNA_def_property_update(prop, NC_NODE|NA_EDITED, NULL);
3230 }
3231
3232 static void rna_def_node_socket_subtype(BlenderRNA *brna, int type, int subtype, const char *name, const char *ui_name)
3233 {
3234         StructRNA *srna;
3235         PropertyRNA *prop = NULL;
3236         PropertySubType propsubtype = PROP_NONE;
3237         
3238         #define SUBTYPE(socktype, stypename, id, idname)        { PROP_##id, #socktype "_" #id, 0, #idname, ""},
3239         static EnumPropertyItem subtype_items[] = {
3240                 NODE_DEFINE_SUBTYPES
3241                 {0, NULL, 0, NULL, NULL}
3242         };
3243         #undef SUBTYPE
3244
3245         #define SUBTYPE(socktype, stypename, id, idname)        if (subtype == (PROP_##id))     propsubtype = PROP_##id;
3246         NODE_DEFINE_SUBTYPES
3247         #undef SUBTYPE
3248         
3249         srna = RNA_def_struct(brna, name, "NodeSocket");
3250         RNA_def_struct_ui_text(srna, ui_name, "Input or output socket of a node");
3251         RNA_def_struct_sdna(srna, "bNodeSocket");
3252         RNA_def_struct_ui_icon(srna, ICON_PLUG);
3253         RNA_def_struct_path_func(srna, "rna_NodeSocket_path");
3254         
3255         switch (type) {
3256         case SOCK_INT:
3257                 RNA_def_struct_sdna_from(srna, "bNodeSocketValueInt", "default_value");
3258                 
3259                 prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
3260                 RNA_def_property_enum_sdna(prop, NULL, "subtype");
3261                 RNA_def_property_enum_items(prop, subtype_items);
3262                 RNA_def_property_ui_text(prop, "Subtype", "Subtype defining the socket value details");
3263                 RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
3264