Cleanup: use `rna_enum_` prefix for RNA enums
[blender.git] / source / blender / makesrna / intern / rna_key.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_key.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28
29 #include "DNA_ID.h"
30 #include "DNA_scene_types.h"
31 #include "DNA_curve_types.h"
32 #include "DNA_key_types.h"
33 #include "DNA_lattice_types.h"
34 #include "DNA_mesh_types.h"
35
36 #include "BLI_utildefines.h"
37
38 #include "BLT_translation.h"
39
40 #include "RNA_access.h"
41 #include "RNA_define.h"
42 #include "RNA_enum_types.h"
43
44 #include "rna_internal.h"
45
46 #ifdef RNA_RUNTIME
47
48 #include <stddef.h>
49
50 #include "DNA_object_types.h"
51
52 #include "BKE_animsys.h"
53 #include "BKE_depsgraph.h"
54 #include "BKE_key.h"
55 #include "BKE_main.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 static Key *rna_ShapeKey_find_key(ID *id)
61 {
62         switch (GS(id->name)) {
63                 case ID_CU: return ((Curve *)id)->key;
64                 case ID_KE: return (Key *)id;
65                 case ID_LT: return ((Lattice *)id)->key;
66                 case ID_ME: return ((Mesh *)id)->key;
67                 case ID_OB: return BKE_key_from_object((Object *)id);
68                 default: return NULL;
69         }
70 }
71
72 static void rna_ShapeKey_name_set(PointerRNA *ptr, const char *value)
73 {
74         KeyBlock *kb = ptr->data;
75         char oldname[sizeof(kb->name)];
76         
77         /* make a copy of the old name first */
78         BLI_strncpy(oldname, kb->name, sizeof(kb->name));
79         
80         /* copy the new name into the name slot */
81         BLI_strncpy_utf8(kb->name, value, sizeof(kb->name));
82         
83         /* make sure the name is truly unique */
84         if (ptr->id.data) {
85                 Key *key = rna_ShapeKey_find_key(ptr->id.data);
86                 BLI_uniquename(&key->block, kb, CTX_DATA_(BLT_I18NCONTEXT_ID_SHAPEKEY, "Key"), '.',
87                                offsetof(KeyBlock, name), sizeof(kb->name));
88         }
89         
90         /* fix all the animation data which may link to this */
91         BKE_animdata_fix_paths_rename_all(NULL, "key_blocks", oldname, kb->name);
92 }
93
94 static float rna_ShapeKey_frame_get(PointerRNA *ptr)
95 {
96         KeyBlock *kb = (KeyBlock *)ptr->data;
97         return kb->pos * 100.0f;  /* Because pos is ctime/100... */
98 }
99
100 static void rna_ShapeKey_value_set(PointerRNA *ptr, float value)
101 {
102         KeyBlock *data = (KeyBlock *)ptr->data;
103         CLAMP(value, data->slidermin, data->slidermax);
104         data->curval = value;
105 }
106
107 static void rna_ShapeKey_value_range(PointerRNA *ptr, float *min, float *max,
108                                      float *UNUSED(softmin), float *UNUSED(softmax))
109 {
110         KeyBlock *data = (KeyBlock *)ptr->data;
111
112         *min = data->slidermin;
113         *max = data->slidermax;
114 }
115
116 /* epsilon for how close one end of shapekey range can get to the other */
117 #define SHAPEKEY_SLIDER_TOL 0.001f
118
119 static void rna_ShapeKey_slider_min_range(PointerRNA *ptr, float *min, float *max,
120                                           float *UNUSED(softmin), float *UNUSED(softmax))
121 {
122         KeyBlock *data = (KeyBlock *)ptr->data;
123
124         *min = -10.0f;
125         *max = data->slidermax - SHAPEKEY_SLIDER_TOL;
126 }
127
128 static void rna_ShapeKey_slider_min_set(PointerRNA *ptr, float value)
129 {
130         KeyBlock *data = (KeyBlock *)ptr->data;
131         float min, max, softmin, softmax;
132         
133         rna_ShapeKey_slider_min_range(ptr, &min, &max, &softmin, &softmax);
134         CLAMP(value, min, max);
135         data->slidermin = value;
136 }
137
138 static void rna_ShapeKey_slider_max_range(PointerRNA *ptr, float *min, float *max,
139                                           float *UNUSED(softmin), float *UNUSED(softmax))
140 {
141         KeyBlock *data = (KeyBlock *)ptr->data;
142
143         *min = data->slidermin + SHAPEKEY_SLIDER_TOL;
144         *max = 10.0f;
145 }
146
147 static void rna_ShapeKey_slider_max_set(PointerRNA *ptr, float value)
148 {
149         KeyBlock *data = (KeyBlock *)ptr->data;
150         float min, max, softmin, softmax;
151         
152         rna_ShapeKey_slider_max_range(ptr, &min, &max, &softmin, &softmax);
153         CLAMP(value, min, max);
154         data->slidermax = value;
155 }
156
157 #undef SHAPEKEY_SLIDER_TOL
158
159 /* ***** Normals accessors for shapekeys. ***** */
160 /* Note: with this we may recompute several times the same data, should we want to access verts, then polys, then loops
161  *       normals... However, such case looks rather unlikely - and not worth adding some kind of caching in KeyBlocks.
162  */
163
164 static Mesh *rna_KeyBlock_normals_get_mesh(PointerRNA *ptr, ID *id)
165 {
166         Key *key = rna_ShapeKey_find_key((id == NULL && ptr != NULL) ? ptr->id.data : id);
167         id = key ? key->from : NULL;
168
169         if (id != NULL) {
170                 switch (GS(id->name)) {
171                         case ID_ME:
172                                 return (Mesh *)id;
173                         case ID_OB:
174                         {
175                                 Object *ob = (Object *)id;
176                                 if (ob->type == OB_MESH) {
177                                         return ob->data;
178                                 }
179                         }
180                 }
181         }
182
183         return NULL;
184 }
185
186 static int rna_KeyBlock_normals_vert_len(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
187 {
188         Mesh *me = rna_KeyBlock_normals_get_mesh(ptr, NULL);
189
190         length[0] = me ? me->totvert : 0;
191         length[1] = 3;
192
193         return (length[0] * length[1]);
194 }
195
196 static void rna_KeyBlock_normals_vert_calc(ID *id, KeyBlock *data, int *normals_len, float **normals)
197 {
198         Mesh *me = rna_KeyBlock_normals_get_mesh(NULL, id);
199
200         *normals_len = (me ? me->totvert : 0) * 3;
201
202         if (ELEM(NULL, me, data) || (me->totvert == 0)) {
203                 *normals = NULL;
204                 return;
205         }
206
207         *normals = MEM_mallocN(sizeof(**normals) * (size_t)(*normals_len), __func__);
208
209         BKE_keyblock_mesh_calc_normals(data, me, (float (*)[3])(*normals), NULL, NULL);
210 }
211
212 static int rna_KeyBlock_normals_poly_len(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
213 {
214         Mesh *me = rna_KeyBlock_normals_get_mesh(ptr, NULL);
215
216         length[0] = me ? me->totpoly : 0;
217         length[1] = 3;
218
219         return (length[0] * length[1]);
220 }
221
222 static void rna_KeyBlock_normals_poly_calc(ID *id, KeyBlock *data, int *normals_len, float **normals)
223 {
224         Mesh *me = rna_KeyBlock_normals_get_mesh(NULL, id);
225
226         *normals_len = (me ? me->totpoly : 0) * 3;
227
228         if (ELEM(NULL, me, data) || (me->totpoly == 0)) {
229                 *normals = NULL;
230                 return;
231         }
232
233         *normals = MEM_mallocN(sizeof(**normals) * (size_t)(*normals_len), __func__);
234
235         BKE_keyblock_mesh_calc_normals(data, me, NULL, (float (*)[3])(*normals), NULL);
236 }
237
238 static int rna_KeyBlock_normals_loop_len(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
239 {
240         Mesh *me = rna_KeyBlock_normals_get_mesh(ptr, NULL);
241
242         length[0] = me ? me->totloop : 0;
243         length[1] = 3;
244
245         return (length[0] * length[1]);
246 }
247
248 static void rna_KeyBlock_normals_loop_calc(ID *id, KeyBlock *data, int *normals_len, float **normals)
249 {
250         Mesh *me = rna_KeyBlock_normals_get_mesh(NULL, id);
251
252         *normals_len = (me ? me->totloop : 0) * 3;
253
254         if (ELEM(NULL, me, data) || (me->totloop == 0)) {
255                 *normals = NULL;
256                 return;
257         }
258
259         *normals = MEM_mallocN(sizeof(**normals) * (size_t)(*normals_len), __func__);
260
261         BKE_keyblock_mesh_calc_normals(data, me, NULL, NULL, (float (*)[3])(*normals));
262 }
263
264
265 PointerRNA rna_object_shapekey_index_get(ID *id, int value)
266 {
267         Key *key = rna_ShapeKey_find_key(id);
268         KeyBlock *kb = NULL;
269         PointerRNA ptr;
270
271         if (key && value < key->totkey)
272                 kb = BLI_findlink(&key->block, value);
273         
274         RNA_pointer_create(id, &RNA_ShapeKey, kb, &ptr);
275
276         return ptr;
277 }
278
279 int rna_object_shapekey_index_set(ID *id, PointerRNA value, int current)
280 {
281         Key *key = rna_ShapeKey_find_key(id);
282
283         if (key) {
284                 int a = BLI_findindex(&key->block, value.data);
285                 if (a != -1) return a;
286         }
287         
288         return current;
289 }
290
291 static PointerRNA rna_ShapeKey_relative_key_get(PointerRNA *ptr)
292 {
293         KeyBlock *kb = (KeyBlock *)ptr->data;
294
295         return rna_object_shapekey_index_get(ptr->id.data, kb->relative);
296 }
297
298 static void rna_ShapeKey_relative_key_set(PointerRNA *ptr, PointerRNA value)
299 {
300         KeyBlock *kb = (KeyBlock *)ptr->data;
301
302         kb->relative = rna_object_shapekey_index_set(ptr->id.data, value, kb->relative);
303 }
304
305 static void rna_ShapeKeyPoint_co_get(PointerRNA *ptr, float *values)
306 {
307         float *vec = (float *)ptr->data;
308
309         values[0] = vec[0];
310         values[1] = vec[1];
311         values[2] = vec[2];
312 }
313
314 static void rna_ShapeKeyPoint_co_set(PointerRNA *ptr, const float *values)
315 {
316         float *vec = (float *)ptr->data;
317
318         vec[0] = values[0];
319         vec[1] = values[1];
320         vec[2] = values[2];
321 }
322
323 static float rna_ShapeKeyCurvePoint_tilt_get(PointerRNA *ptr)
324 {
325         float *vec = (float *)ptr->data;
326         return vec[3];
327 }
328
329 static void rna_ShapeKeyCurvePoint_tilt_set(PointerRNA *ptr, float value)
330 {
331         float *vec = (float *)ptr->data;
332         vec[3] = value;
333 }
334
335 static void rna_ShapeKeyBezierPoint_co_get(PointerRNA *ptr, float *values)
336 {
337         float *vec = (float *)ptr->data;
338
339         values[0] = vec[0 + 3];
340         values[1] = vec[1 + 3];
341         values[2] = vec[2 + 3];
342 }
343
344 static void rna_ShapeKeyBezierPoint_co_set(PointerRNA *ptr, const float *values)
345 {
346         float *vec = (float *)ptr->data;
347
348         vec[0 + 3] = values[0];
349         vec[1 + 3] = values[1];
350         vec[2 + 3] = values[2];
351 }
352
353 static void rna_ShapeKeyBezierPoint_handle_1_co_get(PointerRNA *ptr, float *values)
354 {
355         float *vec = (float *)ptr->data;
356
357         values[0] = vec[0];
358         values[1] = vec[1];
359         values[2] = vec[2];
360 }
361
362 static void rna_ShapeKeyBezierPoint_handle_1_co_set(PointerRNA *ptr, const float *values)
363 {
364         float *vec = (float *)ptr->data;
365
366         vec[0] = values[0];
367         vec[1] = values[1];
368         vec[2] = values[2];
369 }
370
371 static void rna_ShapeKeyBezierPoint_handle_2_co_get(PointerRNA *ptr, float *values)
372 {
373         float *vec = (float *)ptr->data;
374
375         values[0] = vec[6 + 0];
376         values[1] = vec[6 + 1];
377         values[2] = vec[6 + 2];
378 }
379
380 static void rna_ShapeKeyBezierPoint_handle_2_co_set(PointerRNA *ptr, const float *values)
381 {
382         float *vec = (float *)ptr->data;
383
384         vec[6 + 0] = values[0];
385         vec[6 + 1] = values[1];
386         vec[6 + 2] = values[2];
387 }
388
389 #if 0
390 static float rna_ShapeKeyBezierPoint_tilt_get(PointerRNA *ptr)
391 {
392         float *vec = (float *)ptr->data;
393         return vec[10];
394 }
395
396 static void rna_ShapeKeyBezierPoint_tilt_set(PointerRNA *ptr, float value)
397 {
398         float *vec = (float *)ptr->data;
399         vec[10] = value;
400 }
401 #endif
402
403 static void rna_ShapeKey_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
404 {
405         Key *key = rna_ShapeKey_find_key(ptr->id.data);
406         KeyBlock *kb = (KeyBlock *)ptr->data;
407         Curve *cu;
408         Nurb *nu;
409         int tot = kb->totelem, size = key->elemsize;
410         
411         if (GS(key->from->name) == ID_CU) {
412                 cu = (Curve *)key->from;
413                 nu = cu->nurb.first;
414                 
415                 if (nu->bezt) {
416                         tot /= 3;
417                         size *= 3;
418                 }
419         }
420         
421         rna_iterator_array_begin(iter, (void *)kb->data, size, tot, 0, NULL);
422 }
423
424 static int rna_ShapeKey_data_length(PointerRNA *ptr)
425 {
426         Key *key = rna_ShapeKey_find_key(ptr->id.data);
427         KeyBlock *kb = (KeyBlock *)ptr->data;
428         Curve *cu;
429         Nurb *nu;
430         int tot = kb->totelem;
431         
432         if (GS(key->from->name) == ID_CU) {
433                 cu = (Curve *)key->from;
434                 nu = cu->nurb.first;
435                 
436                 if (nu->bezt)
437                         tot /= 3;
438         }
439         
440         return tot;
441 }
442
443 static PointerRNA rna_ShapeKey_data_get(CollectionPropertyIterator *iter)
444 {
445         Key *key = rna_ShapeKey_find_key(iter->parent.id.data);
446         StructRNA *type;
447         Curve *cu;
448         Nurb *nu;
449         
450         if (GS(key->from->name) == ID_CU) {
451                 cu = (Curve *)key->from;
452                 nu = cu->nurb.first;
453                 
454                 if (nu->bezt)
455                         type = &RNA_ShapeKeyBezierPoint;
456                 else
457                         type = &RNA_ShapeKeyCurvePoint;
458         }
459         else
460                 type = &RNA_ShapeKeyPoint;
461         
462         return rna_pointer_inherit_refine(&iter->parent, type, rna_iterator_array_get(iter));
463 }
464
465 static char *rna_ShapeKey_path(PointerRNA *ptr)
466 {
467         KeyBlock *kb = (KeyBlock *)ptr->data;
468         ID *id = ptr->id.data;
469         char name_esc[sizeof(kb->name) * 2];
470
471         BLI_strescape(name_esc, kb->name, sizeof(name_esc));
472
473         if ((id) && (GS(id->name) != ID_KE))
474                 return BLI_sprintfN("shape_keys.key_blocks[\"%s\"]", name_esc);
475         else
476                 return BLI_sprintfN("key_blocks[\"%s\"]", name_esc);
477 }
478
479 static void rna_Key_update_data(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
480 {
481         Key *key = ptr->id.data;
482         Object *ob;
483
484         for (ob = bmain->object.first; ob; ob = ob->id.next) {
485                 if (BKE_key_from_object(ob) == key) {
486                         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
487                         WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob);
488                 }
489         }
490 }
491
492 static KeyBlock *rna_ShapeKeyData_find_keyblock(Key *key, float *point)
493 {
494         KeyBlock *kb;
495         
496         /* sanity checks */
497         if (ELEM(NULL, key, point))
498                 return NULL;
499         
500         /* we'll need to manually search through the keyblocks and check
501          * if the point is somewhere in the middle of each block's data
502          */
503         for (kb = key->block.first; kb; kb = kb->next) {
504                 if (kb->data) {
505                         float *start = (float *)kb->data;
506                         float *end;
507                         
508                         /* easy cases first */
509                         if ((start == NULL) || (start > point)) {
510                                 /* there's no chance point is in array */
511                                 continue;
512                         }
513                         else if (start == point) {
514                                 /* exact match - point is first in array */
515                                 return kb;
516                         }
517                         
518                         /* determine where end of array is
519                          *      - elemsize is in bytes, so use (char *) cast to get array in terms of bytes
520                          */
521                         end = (float *)((char *)start + (key->elemsize * kb->totelem));
522                         
523                         /* if point's address is less than the end, then it is somewhere between start and end, so in array */
524                         if (end > point) {
525                                 /* we've found the owner of the point data */
526                                 return kb;
527                         }
528                 }
529         }
530         
531         return NULL;
532 }
533
534 static int rna_ShapeKeyPoint_get_index(Key *key, KeyBlock *kb, float *point)
535 {
536         /* if we frame the data array and point pointers as (char *), then the difference between
537          * them will be in bytes. Thus, dividing through by key->elemsize (number of bytes per point)
538          * gives us the offset of point from start of array.
539          */
540         char *start = (char *)kb->data;
541         char *pt = (char *)point;
542         
543         return (int)(pt - start) / key->elemsize;
544 }
545
546 static int rna_ShapeKeyBezierPoint_get_index(KeyBlock *kb, float *point)
547 {
548         float *start = (float *)kb->data;
549         
550         /* Unlike with rna_ShapeKeyPoint_get_index(), we cannot use key->elemsize here
551          * since the default value for curves (16) is actually designed for BPoints
552          * (i.e. NURBS Surfaces). The magic number "12" here was found by empirical
553          * testing on a 64-bit system, and is similar to what's used for meshes and 
554          * lattices. For more details, see T38013
555          */
556         return (int)(point - start) / 12;
557 }
558
559 static char *rna_ShapeKeyPoint_path(PointerRNA *ptr)
560 {
561         ID *id = (ID *)ptr->id.data;
562         Key *key = rna_ShapeKey_find_key(ptr->id.data);
563         KeyBlock *kb;
564         float *point = (float *)ptr->data;
565         
566         /* if we can get a key block, we can construct a path */
567         kb = rna_ShapeKeyData_find_keyblock(key, point);
568         
569         if (kb) {
570                 char name_esc_kb[sizeof(kb->name) * 2];
571                 int index;
572                 
573                 if (ptr->type == &RNA_ShapeKeyBezierPoint)
574                         index = rna_ShapeKeyBezierPoint_get_index(kb, point);
575                 else
576                         index = rna_ShapeKeyPoint_get_index(key, kb, point);
577
578                 BLI_strescape(name_esc_kb, kb->name, sizeof(name_esc_kb));
579                 
580                 if (GS(id->name) == ID_KE)
581                         return BLI_sprintfN("key_blocks[\"%s\"].data[%d]", name_esc_kb, index);
582                 else
583                         return BLI_sprintfN("shape_keys.key_blocks[\"%s\"].data[%d]", name_esc_kb, index);
584         }
585         else
586                 return NULL;  /* XXX: there's really no way to resolve this... */
587 }
588
589 #else
590
591 EnumPropertyItem rna_enum_keyblock_type_items[] = {
592         {KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
593         {KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
594         {KEY_CATMULL_ROM, "KEY_CATMULL_ROM", 0, "Catmull-Rom", ""},
595         {KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
596         {0, NULL, 0, NULL, NULL}
597 };
598
599 static void rna_def_keydata(BlenderRNA *brna)
600 {
601         StructRNA *srna;
602         PropertyRNA *prop;
603
604         srna = RNA_def_struct(brna, "ShapeKeyPoint", NULL);
605         RNA_def_struct_ui_text(srna, "Shape Key Point", "Point in a shape key");
606         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
607
608         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
609         RNA_def_property_array(prop, 3);
610         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
611         RNA_def_property_ui_text(prop, "Location", "");
612         RNA_def_property_update(prop, 0, "rna_Key_update_data");
613
614         srna = RNA_def_struct(brna, "ShapeKeyCurvePoint", NULL);
615         RNA_def_struct_ui_text(srna, "Shape Key Curve Point", "Point in a shape key for curves");
616         /* there's nothing type specific here, so this is fine for now */
617         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
618
619         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
620         RNA_def_property_array(prop, 3);
621         RNA_def_property_float_funcs(prop, "rna_ShapeKeyPoint_co_get", "rna_ShapeKeyPoint_co_set", NULL);
622         RNA_def_property_ui_text(prop, "Location", "");
623         RNA_def_property_update(prop, 0, "rna_Key_update_data");
624
625         prop = RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
626         RNA_def_property_float_funcs(prop, "rna_ShapeKeyCurvePoint_tilt_get", "rna_ShapeKeyCurvePoint_tilt_set", NULL);
627         RNA_def_property_ui_text(prop, "Tilt", "");
628         RNA_def_property_update(prop, 0, "rna_Key_update_data");
629
630         srna = RNA_def_struct(brna, "ShapeKeyBezierPoint", NULL);
631         RNA_def_struct_ui_text(srna, "Shape Key Bezier Point", "Point in a shape key for Bezier curves");
632         /* there's nothing type specific here, so this is fine for now */
633         RNA_def_struct_path_func(srna, "rna_ShapeKeyPoint_path");
634
635         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
636         RNA_def_property_array(prop, 3);
637         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_co_get", "rna_ShapeKeyBezierPoint_co_set", NULL);
638         RNA_def_property_ui_text(prop, "Location", "");
639         RNA_def_property_update(prop, 0, "rna_Key_update_data");
640
641         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
642         RNA_def_property_array(prop, 3);
643         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_1_co_get",
644                                      "rna_ShapeKeyBezierPoint_handle_1_co_set", NULL);
645         RNA_def_property_ui_text(prop, "Handle 1 Location", "");
646         RNA_def_property_update(prop, 0, "rna_Key_update_data");
647
648         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
649         RNA_def_property_array(prop, 3);
650         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_handle_2_co_get",
651                                      "rna_ShapeKeyBezierPoint_handle_2_co_set", NULL);
652         RNA_def_property_ui_text(prop, "Handle 2 Location", "");
653         RNA_def_property_update(prop, 0, "rna_Key_update_data");
654
655         /* appears to be unused currently */
656 #if 0
657         prop = RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
658         RNA_def_property_float_funcs(prop, "rna_ShapeKeyBezierPoint_tilt_get", "rna_ShapeKeyBezierPoint_tilt_set", NULL);
659         RNA_def_property_ui_text(prop, "Tilt", "");
660         RNA_def_property_update(prop, 0, "rna_Key_update_data");
661 #endif
662 }
663
664 static void rna_def_keyblock(BlenderRNA *brna)
665 {
666         StructRNA *srna;
667         PropertyRNA *prop, *parm;
668         FunctionRNA *func;
669
670         srna = RNA_def_struct(brna, "ShapeKey", NULL);
671         RNA_def_struct_ui_text(srna, "Shape Key", "Shape key in a shape keys data-block");
672         RNA_def_struct_sdna(srna, "KeyBlock");
673         RNA_def_struct_path_func(srna, "rna_ShapeKey_path");
674         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
675
676         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
677         RNA_def_property_ui_text(prop, "Name", "Name of Shape Key");
678         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ShapeKey_name_set");
679         RNA_def_property_update(prop, 0, "rna_Key_update_data");
680         RNA_def_struct_name_property(srna, prop);
681
682         /* keys need to be sorted to edit this */
683         prop = RNA_def_property(srna, "frame", PROP_FLOAT, PROP_TIME);
684         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
685         RNA_def_property_float_sdna(prop, NULL, "pos");
686         RNA_def_property_float_funcs(prop, "rna_ShapeKey_frame_get", NULL, NULL);
687         RNA_def_property_ui_text(prop, "Frame", "Frame for absolute keys");
688         RNA_def_property_update(prop, 0, "rna_Key_update_data");
689         
690         /* for now, this is editable directly, as users can set this even if they're not animating them
691          * (to test results) */
692         prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_FACTOR);
693         RNA_def_property_float_sdna(prop, NULL, "curval");
694         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_value_set", "rna_ShapeKey_value_range");
695         RNA_def_property_ui_range(prop, -10.0f, 10.0f, 10, 3);
696         RNA_def_property_ui_text(prop, "Value", "Value of shape key at the current frame");
697         RNA_def_property_update(prop, 0, "rna_Key_update_data");
698
699         prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
700         RNA_def_property_enum_sdna(prop, NULL, "type");
701         RNA_def_property_enum_items(prop, rna_enum_keyblock_type_items);
702         RNA_def_property_ui_text(prop, "Interpolation", "Interpolation type for absolute shape keys");
703         RNA_def_property_update(prop, 0, "rna_Key_update_data");
704
705         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
706         RNA_def_property_string_sdna(prop, NULL, "vgroup");
707         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex weight group, to blend with basis shape");
708         RNA_def_property_update(prop, 0, "rna_Key_update_data");
709
710         prop = RNA_def_property(srna, "relative_key", PROP_POINTER, PROP_NONE);
711         RNA_def_property_struct_type(prop, "ShapeKey");
712         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
713         RNA_def_property_pointer_funcs(prop, "rna_ShapeKey_relative_key_get",
714                                        "rna_ShapeKey_relative_key_set", NULL, NULL);
715         RNA_def_property_ui_text(prop, "Relative Key", "Shape used as a relative key");
716         RNA_def_property_update(prop, 0, "rna_Key_update_data");
717
718         prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
719         RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYBLOCK_MUTE);
720         RNA_def_property_ui_text(prop, "Mute", "Mute this shape key");
721         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
722         RNA_def_property_update(prop, 0, "rna_Key_update_data");
723
724         prop = RNA_def_property(srna, "slider_min", PROP_FLOAT, PROP_NONE);
725         RNA_def_property_float_sdna(prop, NULL, "slidermin");
726         RNA_def_property_range(prop, -10.0f, 10.0f);
727         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_slider_min_set", "rna_ShapeKey_slider_min_range");
728         RNA_def_property_ui_text(prop, "Slider Min", "Minimum for slider");
729
730         prop = RNA_def_property(srna, "slider_max", PROP_FLOAT, PROP_NONE);
731         RNA_def_property_float_sdna(prop, NULL, "slidermax");
732         RNA_def_property_range(prop, -10.0f, 10.0f);
733         RNA_def_property_float_default(prop, 1.0f);
734         RNA_def_property_float_funcs(prop, NULL, "rna_ShapeKey_slider_max_set", "rna_ShapeKey_slider_max_range");
735         RNA_def_property_ui_text(prop, "Slider Max", "Maximum for slider");
736
737         prop = RNA_def_property(srna, "data", PROP_COLLECTION, PROP_NONE);
738         RNA_def_property_collection_sdna(prop, NULL, "data", "totelem");
739         RNA_def_property_struct_type(prop, "UnknownType");
740         RNA_def_property_ui_text(prop, "Data", "");
741         RNA_def_property_collection_funcs(prop, "rna_ShapeKey_data_begin", NULL, NULL, "rna_ShapeKey_data_get",
742                                           "rna_ShapeKey_data_length", NULL, NULL, NULL);
743
744         /* XXX multi-dim dynamic arrays are very badly supported by (py)rna currently, those are defined for the day
745          *     it works better, for now user will get a 1D tuple...
746          **/
747         func = RNA_def_function(srna, "normals_vertex_get", "rna_KeyBlock_normals_vert_calc");
748         RNA_def_function_ui_description(func, "Compute local space vertices' normals for this shape key");
749         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
750         parm = RNA_def_property(func, "normals", PROP_FLOAT, /* PROP_DIRECTION */ PROP_NONE);
751         RNA_def_property_flag(parm, PROP_DYNAMIC | PROP_OUTPUT);
752         RNA_def_property_multi_array(parm, 2, NULL);
753         RNA_def_property_range(parm, -1.0f, 1.0f);
754         RNA_def_property_dynamic_array_funcs(parm, "rna_KeyBlock_normals_vert_len");
755
756         func = RNA_def_function(srna, "normals_polygon_get", "rna_KeyBlock_normals_poly_calc");
757         RNA_def_function_ui_description(func, "Compute local space faces' normals for this shape key");
758         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
759         parm = RNA_def_property(func, "normals", PROP_FLOAT, /* PROP_DIRECTION */ PROP_NONE);
760         RNA_def_property_flag(parm, PROP_DYNAMIC | PROP_OUTPUT);
761         RNA_def_property_multi_array(parm, 2, NULL);
762         RNA_def_property_range(parm, -1.0f, 1.0f);
763         RNA_def_property_dynamic_array_funcs(parm, "rna_KeyBlock_normals_poly_len");
764
765         func = RNA_def_function(srna, "normals_split_get", "rna_KeyBlock_normals_loop_calc");
766         RNA_def_function_ui_description(func, "Compute local space face corners' normals for this shape key");
767         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
768         parm = RNA_def_property(func, "normals", PROP_FLOAT, /* PROP_DIRECTION */ PROP_NONE);
769         RNA_def_property_flag(parm, PROP_DYNAMIC | PROP_OUTPUT);
770         RNA_def_property_multi_array(parm, 2, NULL);
771         RNA_def_property_range(parm, -1.0f, 1.0f);
772         RNA_def_property_dynamic_array_funcs(parm, "rna_KeyBlock_normals_loop_len");
773 }
774
775 static void rna_def_key(BlenderRNA *brna)
776 {
777         StructRNA *srna;
778         PropertyRNA *prop;
779
780         srna = RNA_def_struct(brna, "Key", "ID");
781         RNA_def_struct_ui_text(srna, "Key", "Shape keys data-block containing different shapes of geometric data-blocks");
782         RNA_def_struct_ui_icon(srna, ICON_SHAPEKEY_DATA);
783
784         prop = RNA_def_property(srna, "reference_key", PROP_POINTER, PROP_NONE);
785         RNA_def_property_flag(prop, PROP_NEVER_NULL);
786         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
787         RNA_def_property_pointer_sdna(prop, NULL, "refkey");
788         RNA_def_property_ui_text(prop, "Reference Key", "");
789
790         prop = RNA_def_property(srna, "key_blocks", PROP_COLLECTION, PROP_NONE);
791         RNA_def_property_collection_sdna(prop, NULL, "block", NULL);
792         RNA_def_property_struct_type(prop, "ShapeKey");
793         RNA_def_property_ui_text(prop, "Key Blocks", "Shape keys");
794
795         rna_def_animdata_common(srna);
796
797         prop = RNA_def_property(srna, "user", PROP_POINTER, PROP_NONE);
798         RNA_def_property_flag(prop, PROP_NEVER_NULL);
799         RNA_def_property_pointer_sdna(prop, NULL, "from");
800         RNA_def_property_ui_text(prop, "User", "Datablock using these shape keys");
801
802         prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
803         RNA_def_property_boolean_sdna(prop, NULL, "type", KEY_RELATIVE);
804         RNA_def_property_ui_text(prop, "Relative",
805                                  "Make shape keys relative, "
806                                  "otherwise play through shapes as a sequence using the evaluation time");
807         RNA_def_property_update(prop, 0, "rna_Key_update_data");
808
809         prop = RNA_def_property(srna, "eval_time", PROP_FLOAT, PROP_NONE);
810         RNA_def_property_float_sdna(prop, NULL, "ctime");
811         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
812         RNA_def_property_ui_text(prop, "Evaluation Time", "Evaluation time for absolute shape keys");
813         RNA_def_property_update(prop, 0, "rna_Key_update_data");
814 }
815
816 void RNA_def_key(BlenderRNA *brna)
817 {
818         rna_def_key(brna);
819         rna_def_keyblock(brna);
820         rna_def_keydata(brna);
821 }
822
823 #endif