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