Bugfixes:
[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 char *rna_ShapeKey_path(PointerRNA *ptr)
261 {
262         return BLI_sprintfN("keys[\"%s\"]", ((KeyBlock*)ptr->data)->name);
263 }
264
265 static void rna_Key_update_data(bContext *C, PointerRNA *ptr)
266 {
267         Main *bmain= CTX_data_main(C);
268         Key *key= ptr->id.data;
269         Object *ob;
270
271         for(ob=bmain->object.first; ob; ob= ob->id.next) {
272                 if(ob_get_key(ob) == key) {
273                         DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
274                         WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
275                 }
276         }
277 }
278
279 #else
280
281 static void rna_def_keydata(BlenderRNA *brna)
282 {
283         StructRNA *srna;
284         PropertyRNA *prop;
285
286         srna= RNA_def_struct(brna, "ShapeKeyPoint", NULL);
287         RNA_def_struct_ui_text(srna, "Shape Key Point", "Point in a shape key.");
288
289         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
290         RNA_def_property_array(prop, 3);
291         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
292         RNA_def_property_ui_text(prop, "Location", "");
293         RNA_def_property_update(prop, 0, "rna_Key_update_data");
294
295         srna= RNA_def_struct(brna, "ShapeKeyCurvePoint", NULL);
296         RNA_def_struct_ui_text(srna, "Shape Key Curve Point", "Point in a shape key for curves.");
297
298         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
299         RNA_def_property_array(prop, 3);
300         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
301         RNA_def_property_ui_text(prop, "Location", "");
302         RNA_def_property_update(prop, 0, "rna_Key_update_data");
303
304         prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
305         RNA_def_property_float_funcs(prop, "rna_ShapeKeyCurvePoint_tilt_get", "rna_ShapeKeyCurvePoint_tilt_set", NULL);
306         RNA_def_property_ui_text(prop, "Tilt", "");
307         RNA_def_property_update(prop, 0, "rna_Key_update_data");
308
309         srna= RNA_def_struct(brna, "ShapeKeyBezierPoint", NULL);
310         RNA_def_struct_ui_text(srna, "Shape Key Bezier Point", "Point in a shape key for bezier curves.");
311
312         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
313         RNA_def_property_array(prop, 3);
314         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_co_get", "rna_ShapeKeyBezierPoint_co_set", NULL);
315         RNA_def_property_ui_text(prop, "Location", "");
316         RNA_def_property_update(prop, 0, "rna_Key_update_data");
317
318         prop= RNA_def_property(srna, "handle_1_co", PROP_FLOAT, PROP_TRANSLATION);
319         RNA_def_property_array(prop, 3);
320         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_1_co_get", "rna_ShapeKeyBezierPoint_handle_1_co_set", NULL);
321         RNA_def_property_ui_text(prop, "Handle 1 Location", "");
322         RNA_def_property_update(prop, 0, "rna_Key_update_data");
323
324         prop= RNA_def_property(srna, "handle_2_co", PROP_FLOAT, PROP_TRANSLATION);
325         RNA_def_property_array(prop, 3);
326         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_2_co_get", "rna_ShapeKeyBezierPoint_handle_2_co_set", NULL);
327         RNA_def_property_ui_text(prop, "Handle 2 Location", "");
328         RNA_def_property_update(prop, 0, "rna_Key_update_data");
329
330         /* appears to be unused currently
331         prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
332         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_tilt_get", "rna_ShapeKeyBezierPoint_tilt_set", NULL);
333         RNA_def_property_ui_text(prop, "Tilt", "");
334         RNA_def_property_update(prop, 0, "rna_Key_update_data"); */
335 }
336
337 static void rna_def_keyblock(BlenderRNA *brna)
338 {
339         StructRNA *srna;
340         PropertyRNA *prop;
341
342         static EnumPropertyItem prop_keyblock_type_items[] = {
343                 {KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
344                 {KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
345                 {KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
346                 {0, NULL, 0, NULL, NULL}};
347
348         srna= RNA_def_struct(brna, "ShapeKey", NULL);
349         RNA_def_struct_ui_text(srna, "Shape Key", "Shape key in a shape keys datablock.");
350         RNA_def_struct_sdna(srna, "KeyBlock");
351         RNA_def_struct_path_func(srna, "rna_ShapeKey_path");
352         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
353
354         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
355         RNA_def_property_ui_text(prop, "Name", "");
356         RNA_def_struct_name_property(srna, prop);
357
358         /* keys need to be sorted to edit this */
359         prop= RNA_def_property(srna, "frame", PROP_FLOAT, PROP_TIME);
360         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
361         RNA_def_property_float_sdna(prop, NULL, "pos");
362         RNA_def_property_ui_text(prop, "Frame", "Frame for absolute keys.");
363         RNA_def_property_update(prop, 0, "rna_Key_update_data");
364         
365         /* for now, this is editable directly, as users can set this even if they're not animating them (to test results) */
366         prop= RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE);
367         RNA_def_property_float_sdna(prop, NULL, "curval");
368         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_value_set", "rna_ShapeKey_value_range");
369         RNA_def_property_ui_text(prop, "Value", "Value of shape key at the current frame.");
370         RNA_def_property_update(prop, 0, "rna_Key_update_data");
371
372         prop= RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
373         RNA_def_property_enum_sdna(prop, NULL, "type");
374         RNA_def_property_enum_items(prop, prop_keyblock_type_items);
375         RNA_def_property_ui_text(prop, "Interpolation", "Interpolation type.");
376         RNA_def_property_update(prop, 0, "rna_Key_update_data");
377
378         prop= RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
379         RNA_def_property_string_sdna(prop, NULL, "vgroup");
380         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex weight group, to blend with basis shape.");
381         RNA_def_property_update(prop, 0, "rna_Key_update_data");
382
383         prop= RNA_def_property(srna, "relative_key", PROP_POINTER, PROP_NONE);
384         RNA_def_property_struct_type(prop, "ShapeKey");
385         RNA_def_property_flag(prop, PROP_EDITABLE);
386         RNA_def_property_pointer_funcs(prop, "rna_ShapeKey_relative_key_get", "rna_ShapeKey_relative_key_set", NULL);
387         RNA_def_property_ui_text(prop, "Relative Key", "Shape used as a relative key.");
388         RNA_def_property_update(prop, 0, "rna_Key_update_data");
389
390         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
391         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYBLOCK_MUTE);
392         RNA_def_property_ui_text(prop, "Mute", "Mute this shape key.");
393         RNA_def_property_ui_icon(prop, ICON_MUTE_IPO_OFF, 1);
394         RNA_def_property_update(prop, 0, "rna_Key_update_data");
395
396         prop= RNA_def_property(srna, "slider_min", PROP_FLOAT, PROP_NONE);
397         RNA_def_property_float_sdna(prop, NULL, "slidermin");
398         RNA_def_property_range(prop, -10.0f, 10.0f);
399         RNA_def_property_ui_text(prop, "Slider Min", "Minimum for slider.");
400
401         prop= RNA_def_property(srna, "slider_max", PROP_FLOAT, PROP_NONE);
402         RNA_def_property_float_sdna(prop, NULL, "slidermax");
403         RNA_def_property_range(prop, -10.0f, 10.0f);
404         RNA_def_property_float_default(prop, 1.0f);
405         RNA_def_property_ui_text(prop, "Slider Max", "Maximum for slider.");
406
407         prop= RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
408         RNA_def_property_collection_sdna(prop, NULL, "data", "totelem");
409         RNA_def_property_struct_type(prop, "UnknownType");
410         RNA_def_property_ui_text(prop, "Data", "");
411         RNA_def_property_collection_funcs(prop, "rna_ShapeKey_data_begin", 0, 0, "rna_ShapeKey_data_get", "rna_ShapeKey_data_length", 0, 0, 0, 0);
412 }
413
414 static void rna_def_key(BlenderRNA *brna)
415 {
416         StructRNA *srna;
417         PropertyRNA *prop;
418
419         srna= RNA_def_struct(brna, "Key", "ID");
420         RNA_def_struct_ui_text(srna, "Key", "Shape keys datablock containing different shapes of geometric datablocks.");
421         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
422
423         prop= RNA_def_property(srna, "reference_key", PROP_POINTER, PROP_NONE);
424         RNA_def_property_flag(prop, PROP_NEVER_NULL);
425         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
426         RNA_def_property_pointer_sdna(prop, NULL, "refkey");
427         RNA_def_property_ui_text(prop, "Reference Key", "");
428
429         prop= RNA_def_property(srna, "keys", PROP_COLLECTION, PROP_NONE);
430         RNA_def_property_collection_sdna(prop, NULL, "block", NULL);
431         RNA_def_property_struct_type(prop, "ShapeKey");
432         RNA_def_property_ui_text(prop, "Keys", "Shape keys.");
433
434         rna_def_animdata_common(srna);
435
436         prop= RNA_def_property(srna, "user", PROP_POINTER, PROP_NONE);
437         RNA_def_property_flag(prop, PROP_NEVER_NULL);
438         RNA_def_property_pointer_sdna(prop, NULL, "from");
439         RNA_def_property_ui_text(prop, "User", "Datablock using these shape keys.");
440
441         prop= RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
442         RNA_def_property_boolean_sdna(prop, NULL, "type", KEY_RELATIVE);
443         RNA_def_property_ui_text(prop, "Relative", "Makes shape keys relative.");
444         RNA_def_property_update(prop, 0, "rna_Key_update_data");
445
446         prop= RNA_def_property(srna, "slurph", PROP_INT, PROP_UNSIGNED);
447         RNA_def_property_int_sdna(prop, NULL, "slurph");
448         RNA_def_property_range(prop, -500, 500);
449         RNA_def_property_ui_text(prop, "Slurph", "Creates a delay in amount of frames in applying keypositions, first vertex goes first.");
450         RNA_def_property_update(prop, 0, "rna_Key_update_data");
451 }
452
453 void RNA_def_key(BlenderRNA *brna)
454 {
455         rna_def_key(brna);
456         rna_def_keyblock(brna);
457         rna_def_keydata(brna);
458 }
459
460 #endif
461