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