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