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