RNA:
[blender-staging.git] / source / blender / makesrna / intern / rna_nodetree.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Blender Foundation (2008), Nathan Letwory, Robin Allen
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "RNA_define.h"
29 #include "RNA_types.h"
30
31 #include "rna_internal.h"
32
33 #include "DNA_node_types.h"
34 #include "BKE_node.h"
35
36 #ifdef RNA_RUNTIME
37
38 StructRNA *rna_Node_refine(struct PointerRNA *ptr)
39 {
40         bNode *node= (bNode*)ptr->data;
41
42         switch(node->type) {
43                 
44                 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
45                         case ID: return &RNA_##Category##StructName;
46                                 
47                 #include "rna_nodetree_types.h"
48                 
49                 #undef DefNode
50                 
51                 default:
52                         return &RNA_Node;
53         }
54 }
55
56 #else
57
58 #define MaxNodes 1000
59
60 enum
61 {
62         Category_NoCategory,
63         Category_ShaderNode,
64         Category_CompositorNode,
65         Category_TextureNode
66 };
67
68 typedef struct NodeInfo
69 {
70         int defined;
71         int category;
72         const char *enum_name;
73         const char *struct_name;
74         const char *base_name;
75         const char *ui_name;
76         const char *ui_desc;
77 } NodeInfo;
78
79 static NodeInfo nodes[MaxNodes];
80
81 static void reg_node(
82         int ID, 
83         int category,
84         const char *enum_name,
85         const char *struct_name,
86         const char *base_name,
87         const char *ui_name,
88         const char *ui_desc
89 ){
90         NodeInfo *ni = nodes + ID;
91         
92         ni->defined = 1;
93         ni->category = category;
94         ni->enum_name = enum_name;
95         ni->struct_name = struct_name;
96         ni->base_name = base_name;
97         ni->ui_name = ui_name;
98         ni->ui_desc = ui_desc;
99 }
100
101 static void init(void)
102 {
103         memset(nodes, 0, sizeof nodes);
104         
105         #define Str(x) #x
106         
107         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
108                 reg_node(ID, Category_##Category, EnumName, Str(Category##StructName), #Category, UIName, UIDesc);
109                 
110         #include "rna_nodetree_types.h"
111         
112         #undef DefNode
113         #undef Str
114 }
115
116 static StructRNA* def_node(BlenderRNA *brna, int node_id)
117 {
118         StructRNA *srna;
119         NodeInfo *node = nodes + node_id;
120         
121         srna= RNA_def_struct(brna, node->struct_name, node->base_name);
122         RNA_def_struct_ui_text(srna, node->ui_name, node->ui_desc);
123         RNA_def_struct_sdna(srna, "bNode");
124         
125         return srna;
126 }
127
128 static EnumPropertyItem* alloc_node_type_items(int category)
129 {
130         int i;
131         int count = 2;
132         EnumPropertyItem *item, *items;
133         
134         for(i=0; i<MaxNodes; i++)
135                 if(nodes[i].defined && nodes[i].category == category)
136                         count++;
137                 
138         item = items = malloc(count * sizeof(EnumPropertyItem));
139         
140         for(i=0; i<MaxNodes; i++) {
141                 NodeInfo *node = nodes + i;
142                 if(node->defined && node->category == category) {
143                         item->value = i;
144                         item->identifier = node->enum_name;
145                         item->name = node->ui_name;
146                         item->description = node->ui_desc;
147                 
148                         item++;
149                 }
150         }
151         
152         item->value = NODE_DYNAMIC;
153         item->identifier = "SCRIPT";
154         item->name = "Script";
155         item->description = "";
156         
157         item++;
158         
159         memset(item, 0, sizeof(EnumPropertyItem));
160         
161         return items;
162 }
163
164
165 /* -- Common nodes ---------------------------------------------------------- */
166
167 static void def_math(BlenderRNA *brna, int id)
168 {
169         StructRNA *srna;
170         PropertyRNA *prop;
171         
172         static EnumPropertyItem items[] ={
173                 { 0, "ADD",          "Add",          ""},
174                 { 1, "SUBTRACT",     "Subtract",     ""},
175                 { 2, "MULTIPLY",     "Multiply",     ""},
176                 { 3, "DIVIDE",       "Divide",       ""},
177                 { 4, "SINE",         "Sine",         ""},
178                 { 5, "COSINE",       "Cosine",       ""},
179                 { 6, "TANGENT",      "Tangent",      ""},
180                 { 7, "ARCSINE",      "Arcsine",      ""},
181                 { 8, "ARCCOSINE",    "Arccosine",    ""},
182                 { 9, "ARCTANGENT",   "Arctangent",   ""},
183                 {10, "POWER",        "Power",        ""},
184                 {11, "LOGARITHM",    "Logarithm",    ""},
185                 {12, "MINIMUM",      "Minimum",      ""},
186                 {13, "MAXIMUM",      "Maximum",      ""},
187                 {14, "ROUND",        "Round",        ""},
188                 {15, "LESS_THAN",    "Less Than",    ""},
189                 {16, "GREATER_THAN", "Greater Than", ""},
190                 
191                 {0, NULL, NULL, NULL}
192         };
193         
194         srna= def_node(brna, id);
195         
196         prop= RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
197         RNA_def_property_enum_sdna(prop, NULL, "custom1");
198         RNA_def_property_enum_items(prop, items);
199         RNA_def_property_ui_text(prop, "Operation", "");
200 }
201
202 static void def_vector_math(BlenderRNA *brna, int id)
203 {
204         StructRNA *srna;
205         PropertyRNA *prop;
206         
207         static EnumPropertyItem items[] ={
208                 {0, "ADD",           "Add",           ""},
209                 {1, "SUBTRACT",      "Subtract",      ""},
210                 {2, "AVERAGE",       "Average",       ""},
211                 {3, "DOT_PRODUCT",   "Dot Product",   ""},
212                 {4, "CROSS_PRODUCT", "Cross Product", ""},
213                 {5, "NORMALIZE",     "Normalize",     ""},
214                 
215                 {0, NULL, NULL, NULL}
216         };
217         
218         srna= def_node(brna, id);
219         
220         prop= RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
221         RNA_def_property_enum_sdna(prop, NULL, "custom1");
222         RNA_def_property_enum_items(prop, items);
223         RNA_def_property_ui_text(prop, "Operation", "");
224 }
225
226 static void def_rgb_curve(BlenderRNA *brna, int id)
227 {
228         StructRNA *srna;
229         PropertyRNA *prop;
230         
231         srna= def_node(brna, id);
232         
233         prop= RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
234         RNA_def_property_pointer_sdna(prop, NULL, "storage");
235         RNA_def_property_struct_type(prop, "CurveMapping");
236         RNA_def_property_ui_text(prop, "Mapping", "");
237 }
238
239 static void def_vector_curve(BlenderRNA *brna, int id)
240 {
241         StructRNA *srna;
242         PropertyRNA *prop;
243         
244         srna= def_node(brna, id);
245         
246         prop= RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
247         RNA_def_property_pointer_sdna(prop, NULL, "storage");
248         RNA_def_property_struct_type(prop, "CurveMapping");
249         RNA_def_property_ui_text(prop, "Mapping", "");
250 }
251
252 static void def_val_to_rgb(BlenderRNA *brna, int id)
253 {
254         StructRNA *srna;
255 //      PropertyRNA *prop;
256         
257         srna= def_node(brna, id);
258         
259         /* TODO: uncomment when ColorBand is wrapped */
260         /*prop= RNA_def_property(srna, "color_band", PROP_POINTER, PROP_NONE);
261         RNA_def_property_pointer_sdna(prop, NULL, "storage");
262         RNA_def_property_struct_type(prop, "ColorBand");
263         RNA_def_property_ui_text(prop, "Color Band", "");*/
264 }
265
266 static void def_mix_rgb(BlenderRNA *brna, int id)
267 {
268         StructRNA *srna;
269         PropertyRNA *prop;
270         
271         static EnumPropertyItem blend_type_items[] ={
272                 { 0, "MIX",        "Mix",         ""},
273                 { 1, "ADD",        "Add",         ""},
274                 { 3, "SUBTRACT",   "Subtract",    ""},
275                 { 2, "MULTIPLY",   "Multiply",    ""},
276                 { 4, "SCREEN",     "Screen",      ""},
277                 { 9, "OVERLAY",    "Overlay",     ""},
278                 { 5, "DIVIDE",     "Divide",      ""},
279                 { 6, "DIFFERENCE", "Difference",  ""},
280                 { 7, "DARKEN",     "Darken",      ""},
281                 { 8, "LIGHTEN",    "Lighten",     ""},
282                 {10, "DODGE",      "Dodge",       ""},
283                 {11, "BURN",       "Burn",        ""},
284                 {15, "COLOR",      "Color",       ""},
285                 {14, "VALUE",      "Value",       ""},
286                 {13, "SATURATION", "Saturation",  ""},
287                 {12, "HUE",        "Hue",         ""},
288                 {0, NULL, NULL, NULL}
289         };
290         
291         srna= def_node(brna, id);
292         
293         prop= RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
294         RNA_def_property_enum_sdna(prop, NULL, "custom1");
295         RNA_def_property_enum_items(prop, blend_type_items);
296         RNA_def_property_ui_text(prop, "Blend Type", "");
297         
298         prop= RNA_def_property(srna, "alpha", PROP_BOOLEAN, PROP_NONE);
299         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
300         RNA_def_property_ui_text(prop, "Diffuse", "Include alpha of second input in this operation");
301 }
302
303
304 /* -- Shader Node Storage Types --------------------------------------------- */
305
306 static void rna_def_storage_node_geometry(BlenderRNA *brna)
307 {
308         StructRNA *srna;
309         PropertyRNA *prop;
310         
311         srna= RNA_def_struct(brna, "NodeGeometry", NULL);
312         RNA_def_struct_ui_text(srna, "Node Geometry", "");
313         
314         prop= RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
315         RNA_def_property_string_sdna(prop, NULL, "uvname");
316         RNA_def_property_ui_text(prop, "UV Layer", "");
317         
318         prop= RNA_def_property(srna, "color_layer", PROP_STRING, PROP_NONE);
319         RNA_def_property_string_sdna(prop, NULL, "colname");
320         RNA_def_property_ui_text(prop, "Vertex Color Layer", "");
321 }
322
323
324 /* -- Shader Nodes ---------------------------------------------------------- */
325
326 static void def_sh_texture(BlenderRNA *brna, int id)
327 {
328         StructRNA *srna;
329         PropertyRNA *prop;
330         
331         srna= def_node(brna, id);
332         
333         prop= RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
334         RNA_def_property_pointer_sdna(prop, NULL, "id");
335         RNA_def_property_struct_type(prop, "Texture");
336         RNA_def_property_flag(prop, PROP_EDITABLE);
337         RNA_def_property_ui_text(prop, "Texture", "");
338         
339         prop= RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
340         RNA_def_property_int_sdna(prop, NULL, "custom1");
341         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
342 }
343
344 static void def_sh_material(BlenderRNA *brna, int id)
345 {
346         StructRNA *srna;
347         PropertyRNA *prop;
348
349         srna= def_node(brna, id);
350
351         prop= RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
352         RNA_def_property_pointer_sdna(prop, NULL, "id");
353         RNA_def_property_struct_type(prop, "Material");
354         RNA_def_property_flag(prop, PROP_EDITABLE);
355         RNA_def_property_ui_text(prop, "Material", "");
356
357         prop= RNA_def_property(srna, "diffuse", PROP_BOOLEAN, PROP_NONE);
358         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
359         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
360
361         prop= RNA_def_property(srna, "specular", PROP_BOOLEAN, PROP_NONE);
362         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
363         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
364         
365         prop= RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
366         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
367         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
368 }
369
370 static void def_sh_mapping(BlenderRNA *brna, int id)
371 {
372         StructRNA *srna;
373         PropertyRNA *prop;
374         
375         srna= def_node(brna, id);
376         
377         prop= RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
378         RNA_def_property_pointer_sdna(prop, NULL, "storage");
379         RNA_def_property_struct_type(prop, "TexMapping");
380         RNA_def_property_ui_text(prop, "Mapping", "");
381 }
382
383 static void def_sh_geometry(BlenderRNA *brna, int id)
384 {
385         StructRNA *srna;
386         PropertyRNA *prop;
387         
388         srna= def_node(brna, id);
389         
390         prop= RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
391         RNA_def_property_pointer_sdna(prop, NULL, "storage");
392         RNA_def_property_struct_type(prop, "NodeGeometry");
393         RNA_def_property_ui_text(prop, "Settings", "");
394 }
395
396 /* -- Compositor Nodes ------------------------------------------------------ */
397
398 /* -- Texture Nodes --------------------------------------------------------- */
399
400 /* -------------------------------------------------------------------------- */
401
402 static void rna_def_shader_node(BlenderRNA *brna)
403 {
404         StructRNA *srna;
405         PropertyRNA *prop;
406         EnumPropertyItem *node_type_items;
407         
408         node_type_items = alloc_node_type_items(Category_ShaderNode);
409
410         srna= RNA_def_struct(brna, "ShaderNode", "Node");
411         RNA_def_struct_ui_text(srna, "Shader Node", "Material shader node.");
412         RNA_def_struct_sdna(srna, "bNode");
413
414         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
415         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
416         RNA_def_property_enum_items(prop, node_type_items);
417         RNA_def_property_ui_text(prop, "Type", "");
418
419         /* Shader storage types */
420         rna_def_storage_node_geometry(brna);
421 }
422
423 static void rna_def_compositor_node(BlenderRNA *brna)
424 {
425         StructRNA *srna;
426         PropertyRNA *prop;
427         EnumPropertyItem *node_type_items;
428         
429         node_type_items = alloc_node_type_items(Category_CompositorNode);
430         
431         srna= RNA_def_struct(brna, "CompositorNode", "Node");
432         RNA_def_struct_ui_text(srna, "Compositor Node", "");
433         RNA_def_struct_sdna(srna, "bNode");
434
435         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
436         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
437         RNA_def_property_enum_items(prop, node_type_items);
438         RNA_def_property_ui_text(prop, "Type", "");
439 }
440
441 static void rna_def_texture_node(BlenderRNA *brna)
442 {
443         StructRNA *srna;
444         PropertyRNA *prop;
445         EnumPropertyItem *node_type_items;
446         
447         node_type_items = alloc_node_type_items(Category_TextureNode);
448         
449         srna= RNA_def_struct(brna, "TextureNode", "Node");
450         RNA_def_struct_ui_text(srna, "Texture Node", "");
451         RNA_def_struct_sdna(srna, "bNode");
452
453         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
454         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
455         RNA_def_property_enum_items(prop, node_type_items);
456         RNA_def_property_ui_text(prop, "Type", "");
457 }
458
459 /* -------------------------------------------------------------------------- */
460
461 static void rna_def_node(BlenderRNA *brna)
462 {
463         StructRNA *srna;
464         PropertyRNA *prop;
465         
466         srna= RNA_def_struct(brna, "Node", NULL);
467         RNA_def_struct_ui_text(srna, "Node", "Node in a node tree.");
468         RNA_def_struct_sdna(srna, "bNode");
469         RNA_def_struct_refine_func(srna, "rna_Node_refine");
470         
471         prop= RNA_def_property(srna, "location", PROP_FLOAT, PROP_VECTOR);
472         RNA_def_property_float_sdna(prop, NULL, "locx");
473         RNA_def_property_array(prop, 2);
474         RNA_def_property_range(prop, -10000.0f, 10000.0f);
475         RNA_def_property_ui_text(prop, "Location", "");
476         
477         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
478         RNA_def_property_ui_text(prop, "Name", "Node name.");
479         RNA_def_struct_name_property(srna, prop);
480 }
481
482 static void rna_def_nodetree(BlenderRNA *brna)
483 {
484         StructRNA *srna;
485         PropertyRNA *prop;
486         
487         srna= RNA_def_struct(brna, "NodeTree", "ID");
488         RNA_def_struct_ui_text(srna, "Node Tree", "Node tree consisting of linked nodes used for materials, textures and compositing.");
489         RNA_def_struct_sdna(srna, "bNodeTree");
490
491         prop= RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE);
492         RNA_def_property_collection_sdna(prop, NULL, "nodes", NULL);
493         RNA_def_property_struct_type(prop, "Node");
494         RNA_def_property_ui_text(prop, "Nodes", "");
495 }
496
497 static void define_simple_node(BlenderRNA *brna, int id)
498 {
499         def_node(brna, id);
500 }
501
502 static void define_specific_node(BlenderRNA *brna, int id, void (*func)(BlenderRNA*, int))
503 {
504         func(brna, id);
505 }
506
507 void RNA_def_nodetree(BlenderRNA *brna)
508 {
509         init();
510         rna_def_nodetree(brna);
511         rna_def_node(brna);
512         rna_def_shader_node(brna);
513         rna_def_compositor_node(brna);
514         rna_def_texture_node(brna);
515         
516         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
517                 define_specific_node(brna, ID, DefFunc != 0 ? DefFunc : define_simple_node);
518                 
519         #include "rna_nodetree_types.h"
520         
521         #undef DefNode
522 }
523
524 #endif
525