RNA
[blender.git] / source / blender / makesrna / intern / rna_key.c
1 /**
2  * $Id: rna_key.c 19382 2009-03-23 13:24:48Z blendix $
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).
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "RNA_define.h"
28 #include "RNA_types.h"
29
30 #include "rna_internal.h"
31
32 #include "DNA_ID.h"
33 #include "DNA_curve_types.h"
34 #include "DNA_key_types.h"
35 #include "DNA_lattice_types.h"
36 #include "DNA_mesh_types.h"
37
38 #ifdef RNA_RUNTIME
39
40 static Key *rna_ShapeKey_find_key(ID *id)
41 {
42         switch(GS(id->name)) {
43                 case ID_CU: return ((Curve*)id)->key;
44                 case ID_KE: return (Key*)id;
45                 case ID_LT: return ((Lattice*)id)->key;
46                 case ID_ME: return ((Mesh*)id)->key;
47                 default: return NULL;
48         }
49 }
50
51 static PointerRNA rna_ShapeKey_relative_key_get(PointerRNA *ptr)
52 {
53         Key *key= rna_ShapeKey_find_key(ptr->id.data);
54         KeyBlock *kb= (KeyBlock*)ptr->data, *kbrel;
55         int a;
56
57         if(key && kb->relative < key->totkey)
58                 for(a=0, kbrel=key->block.first; kbrel; kbrel=kbrel->next, a++)
59                         if(a == kb->relative)
60                                 return rna_pointer_inherit_refine(ptr, &RNA_ShapeKey, kbrel);
61
62         return rna_pointer_inherit_refine(ptr, NULL, NULL);
63 }
64
65 static void rna_ShapeKeyPoint_co_get(PointerRNA *ptr, float *values)
66 {
67         float *vec= (float*)ptr->data;
68
69         values[0]= vec[0];
70         values[1]= vec[1];
71         values[2]= vec[2];
72 }
73
74 static void rna_ShapeKeyPoint_co_set(PointerRNA *ptr, const float *values)
75 {
76         float *vec= (float*)ptr->data;
77
78         vec[0]= values[0];
79         vec[1]= values[1];
80         vec[2]= values[2];
81 }
82
83 static float rna_ShapeKeyCurvePoint_tilt_get(PointerRNA *ptr)
84 {
85         float *vec= (float*)ptr->data;
86         return vec[3];
87 }
88
89 static void rna_ShapeKeyCurvePoint_tilt_set(PointerRNA *ptr, float value)
90 {
91         float *vec= (float*)ptr->data;
92         vec[3]= value;
93 }
94
95 static void rna_ShapeKeyBezierPoint_co_get(PointerRNA *ptr, float *values)
96 {
97         float *vec= (float*)ptr->data;
98
99         values[0]= vec[0+3];
100         values[1]= vec[1+3];
101         values[2]= vec[2+3];
102 }
103
104 static void rna_ShapeKeyBezierPoint_co_set(PointerRNA *ptr, const float *values)
105 {
106         float *vec= (float*)ptr->data;
107
108         vec[0+3]= values[0];
109         vec[1+3]= values[1];
110         vec[2+3]= values[2];
111 }
112
113 static void rna_ShapeKeyBezierPoint_handle_1_co_get(PointerRNA *ptr, float *values)
114 {
115         float *vec= (float*)ptr->data;
116
117         values[0]= vec[0];
118         values[1]= vec[1];
119         values[2]= vec[2];
120 }
121
122 static void rna_ShapeKeyBezierPoint_handle_1_co_set(PointerRNA *ptr, const float *values)
123 {
124         float *vec= (float*)ptr->data;
125
126         vec[0]= values[0];
127         vec[1]= values[1];
128         vec[2]= values[2];
129 }
130
131 static void rna_ShapeKeyBezierPoint_handle_2_co_get(PointerRNA *ptr, float *values)
132 {
133         float *vec= (float*)ptr->data;
134
135         values[0]= vec[6+0];
136         values[1]= vec[6+1];
137         values[2]= vec[6+2];
138 }
139
140 static void rna_ShapeKeyBezierPoint_handle_2_co_set(PointerRNA *ptr, const float *values)
141 {
142         float *vec= (float*)ptr->data;
143
144         vec[6+0]= values[0];
145         vec[6+1]= values[1];
146         vec[6+2]= values[2];
147 }
148
149 /*static float rna_ShapeKeyBezierPoint_tilt_get(PointerRNA *ptr)
150 {
151         float *vec= (float*)ptr->data;
152         return vec[10];
153 }
154
155 static void rna_ShapeKeyBezierPoint_tilt_set(PointerRNA *ptr, float value)
156 {
157         float *vec= (float*)ptr->data;
158         vec[10]= value;
159 }*/
160
161 static void rna_ShapeKey_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
162 {
163         Key *key= rna_ShapeKey_find_key(ptr->id.data);
164         KeyBlock *kb= (KeyBlock*)ptr->data;
165         Curve *cu;
166         Nurb *nu;
167         int tot= kb->totelem, size= key->elemsize;
168
169     if(GS(key->from->name) == ID_CU) {
170                 cu= (Curve*)key->from;
171                 nu= cu->nurb.first;
172
173                 if(nu->bezt) {
174                         tot /= 3;
175                         size *= 3;
176                 }
177         }
178
179         rna_iterator_array_begin(iter, (void*)kb->data, size, tot, NULL);
180 }
181
182 static int rna_ShapeKey_data_length(PointerRNA *ptr)
183 {
184         Key *key= rna_ShapeKey_find_key(ptr->id.data);
185         KeyBlock *kb= (KeyBlock*)ptr->data;
186         Curve *cu;
187         Nurb *nu;
188         int tot= kb->totelem;
189
190     if(GS(key->from->name) == ID_CU) {
191                 cu= (Curve*)key->from;
192                 nu= cu->nurb.first;
193
194                 if(nu->bezt)
195                         tot /= 3;
196         }
197
198         return tot;
199 }
200
201 static PointerRNA rna_ShapeKey_data_get(CollectionPropertyIterator *iter)
202 {
203         Key *key= rna_ShapeKey_find_key(iter->parent.id.data);
204         StructRNA *type;
205         Curve *cu;
206         Nurb *nu;
207
208         if(GS(key->from->name) == ID_CU) {
209                 cu= (Curve*)key->from;
210                 nu= cu->nurb.first;
211
212                 if(nu->bezt)
213                         type= &RNA_ShapeKeyBezierPoint;
214                 else
215                         type= &RNA_ShapeKeyCurvePoint;
216         }
217         else
218                 type= &RNA_ShapeKeyPoint;
219         
220         return rna_pointer_inherit_refine(&iter->parent, type, rna_iterator_array_get(iter));
221 }
222
223 #else
224
225 static void rna_def_keydata(BlenderRNA *brna)
226 {
227         StructRNA *srna;
228         PropertyRNA *prop;
229
230         srna= RNA_def_struct(brna, "ShapeKeyPoint", NULL);
231         RNA_def_struct_ui_text(srna, "Shape Key Point", "Point in a shape key.");
232
233         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_VECTOR);
234         RNA_def_property_array(prop, 3);
235         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
236         RNA_def_property_ui_text(prop, "Location", "");
237
238         srna= RNA_def_struct(brna, "ShapeKeyCurvePoint", NULL);
239         RNA_def_struct_ui_text(srna, "Shape Key Curve Point", "Point in a shape key for curves.");
240
241         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_VECTOR);
242         RNA_def_property_array(prop, 3);
243         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
244         RNA_def_property_ui_text(prop, "Location", "");
245
246         prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
247         RNA_def_property_float_funcs(prop, "rna_ShapeKeyCurvePoint_tilt_get", "rna_ShapeKeyCurvePoint_tilt_set", NULL);
248         RNA_def_property_ui_text(prop, "Tilt", "");
249
250         srna= RNA_def_struct(brna, "ShapeKeyBezierPoint", NULL);
251         RNA_def_struct_ui_text(srna, "Shape Key Bezier Point", "Point in a shape key for bezier curves.");
252
253         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_VECTOR);
254         RNA_def_property_array(prop, 3);
255         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_co_get", "rna_ShapeKeyBezierPoint_co_set", NULL);
256         RNA_def_property_ui_text(prop, "Location", "");
257
258         prop= RNA_def_property(srna, "handle_1_co", PROP_FLOAT, PROP_VECTOR);
259         RNA_def_property_array(prop, 3);
260         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_1_co_get", "rna_ShapeKeyBezierPoint_handle_1_co_set", NULL);
261         RNA_def_property_ui_text(prop, "Handle 1 Location", "");
262
263         prop= RNA_def_property(srna, "handle_2_co", PROP_FLOAT, PROP_VECTOR);
264         RNA_def_property_array(prop, 3);
265         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_2_co_get", "rna_ShapeKeyBezierPoint_handle_2_co_set", NULL);
266         RNA_def_property_ui_text(prop, "Handle 2 Location", "");
267
268         /* appears to be unused currently
269         prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
270         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_tilt_get", "rna_ShapeKeyBezierPoint_tilt_set", NULL);
271         RNA_def_property_ui_text(prop, "Tilt", "");*/
272 }
273
274 static void rna_def_keyblock(BlenderRNA *brna)
275 {
276         StructRNA *srna;
277         PropertyRNA *prop;
278
279         static EnumPropertyItem prop_keyblock_type_items[] = {
280                 {KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
281                 {KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
282                 {KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
283                 {0, NULL, 0, NULL, NULL}};
284
285         srna= RNA_def_struct(brna, "ShapeKey", NULL);
286         RNA_def_struct_ui_text(srna, "Shape Key", "Shape key in a shape keys datablock.");
287         RNA_def_struct_sdna(srna, "KeyBlock");
288         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
289
290         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
291         RNA_def_property_ui_text(prop, "Name", "");
292         RNA_def_struct_name_property(srna, prop);
293
294         /* keys need to be sorted to edit this */
295         prop= RNA_def_property(srna, "frame", PROP_FLOAT, PROP_NONE);
296         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
297         RNA_def_property_float_sdna(prop, NULL, "pos");
298         RNA_def_property_ui_text(prop, "Frame", "Frame for absolute keys.");
299         
300         /* for now, this is editable directly, as users can set this even if they're not animating them (to test results) */
301         prop= RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE);
302         RNA_def_property_float_sdna(prop, NULL, "curval");
303         RNA_def_property_ui_text(prop, "Value", "Value of shape key at the current frame.");
304
305         prop= RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
306         RNA_def_property_enum_sdna(prop, NULL, "type");
307         RNA_def_property_enum_items(prop, prop_keyblock_type_items);
308         RNA_def_property_ui_text(prop, "Interpolation", "Interpolation type.");
309
310         prop= RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
311         RNA_def_property_string_sdna(prop, NULL, "vgroup");
312         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex weight group, to blend with basis shape.");
313
314         prop= RNA_def_property(srna, "relative_key", PROP_POINTER, PROP_NONE);
315         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
316         RNA_def_property_struct_type(prop, "ShapeKey");
317         RNA_def_property_ui_text(prop, "Relative Key", "Shape used as a relative key.");
318         RNA_def_property_pointer_funcs(prop, "rna_ShapeKey_relative_key_get", NULL, NULL);
319
320         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
321         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYBLOCK_MUTE);
322         RNA_def_property_ui_text(prop, "Mute", "Mute this shape key.");
323
324         prop= RNA_def_property(srna, "slider_min", PROP_FLOAT, PROP_NONE);
325         RNA_def_property_float_sdna(prop, NULL, "slidermin");
326         RNA_def_property_range(prop, -10.0f, 10.0f);
327         RNA_def_property_ui_text(prop, "Slider Min", "Minimum for slider.");
328
329         prop= RNA_def_property(srna, "slider_max", PROP_FLOAT, PROP_NONE);
330         RNA_def_property_float_sdna(prop, NULL, "slidermax");
331         RNA_def_property_range(prop, -10.0f, 10.0f);
332         RNA_def_property_ui_text(prop, "Slider Max", "Maximum for slider.");
333
334         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
335         RNA_def_property_collection_sdna(prop, NULL, "data", "totelem");
336         RNA_def_property_struct_type(prop, "UnknownType");
337         RNA_def_property_ui_text(prop, "Data", "");
338         RNA_def_property_collection_funcs(prop, "rna_ShapeKey_data_begin", 0, 0, "rna_ShapeKey_data_get", "rna_ShapeKey_data_length", 0, 0);
339 }
340
341 static void rna_def_key(BlenderRNA *brna)
342 {
343         StructRNA *srna;
344         PropertyRNA *prop;
345
346         srna= RNA_def_struct(brna, "Key", "ID");
347         RNA_def_struct_ui_text(srna, "Key", "Shape keys datablock containing different shapes of geometric datablocks.");
348         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
349
350         prop= RNA_def_property(srna, "reference_key", PROP_POINTER, PROP_NEVER_NULL);
351         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
352         RNA_def_property_pointer_sdna(prop, NULL, "refkey");
353         RNA_def_property_ui_text(prop, "Reference Key", "");
354
355         prop= RNA_def_property(srna, "keys", PROP_COLLECTION, PROP_NONE);
356         RNA_def_property_collection_sdna(prop, NULL, "block", NULL);
357         RNA_def_property_struct_type(prop, "ShapeKey");
358         RNA_def_property_ui_text(prop, "Keys", "Shape keys.");
359
360         rna_def_animdata_common(srna);
361
362         prop= RNA_def_property(srna, "user", PROP_POINTER, PROP_NEVER_NULL);
363         RNA_def_property_pointer_sdna(prop, NULL, "from");
364         RNA_def_property_ui_text(prop, "User", "Datablock using these shape keys.");
365
366         prop= RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
367         RNA_def_property_boolean_sdna(prop, NULL, "type", KEY_RELATIVE);
368         RNA_def_property_ui_text(prop, "Relative", "Makes shape keys relative.");
369
370         prop= RNA_def_property(srna, "slurph", PROP_INT, PROP_UNSIGNED);
371         RNA_def_property_int_sdna(prop, NULL, "slurph");
372         RNA_def_property_range(prop, -500, 500);
373         RNA_def_property_ui_text(prop, "Slurph", "Creates a delay in amount of frames in applying keypositions, first vertex goes first.");
374 }
375
376 void RNA_def_key(BlenderRNA *brna)
377 {
378         rna_def_key(brna);
379         rna_def_keyblock(brna);
380         rna_def_keydata(brna);
381 }
382
383 #endif
384