Stage two of the giant animation recode project; Ipo/Action/NLA cleanup
[blender.git] / source / blender / src / editkey.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32
33 #include <math.h>
34 #include <string.h>
35
36 #ifndef WIN32
37 #include <unistd.h>
38 #else
39 #include <io.h>
40 #endif   
41
42 #include "MEM_guardedalloc.h"
43
44 #include "BLI_blenlib.h"
45 #include "BLI_arithb.h"
46
47 #include "DNA_curve_types.h"
48 #include "DNA_ipo_types.h"
49 #include "DNA_key_types.h"
50 #include "DNA_mesh_types.h"
51 #include "DNA_meshdata_types.h"
52 #include "DNA_object_types.h"
53 #include "DNA_screen_types.h"
54 #include "DNA_space_types.h"
55 #include "DNA_userdef_types.h"
56 #include "DNA_view2d_types.h"
57 #include "DNA_lattice_types.h"
58 #include "DNA_scene_types.h"
59
60 #include "BKE_anim.h"
61 #include "BKE_curve.h"
62 #include "BKE_depsgraph.h"
63 #include "BKE_global.h"
64 #include "BKE_ipo.h"
65 #include "BKE_key.h"
66 #include "BKE_library.h"
67 #include "BKE_main.h"
68 #include "BKE_object.h"
69 #include "BKE_utildefines.h"
70
71 #include "BIF_editkey.h"
72 #include "BIF_editview.h"
73 #include "BIF_mywindow.h"
74 #include "BIF_screen.h"
75 #include "BIF_space.h"
76 #include "BIF_toolbox.h"
77 #include "BIF_interface.h"
78
79 #include "BSE_editipo.h"
80 #include "BSE_trans_types.h"
81
82 #include "BDR_editobject.h"
83
84 #include "blendef.h"
85 #include "mydevice.h"
86
87 extern ListBase editNurb; /* in editcurve.c */
88
89 /* temporary storage for slider values */
90 float meshslidervals[64] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
91                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
92                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
93                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
94                                                         0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
95                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
96                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
97                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
98
99 static IpoCurve *get_key_icu(Key *key, int keynum) 
100 {
101         /* return the Ipocurve that has the specified
102          * keynum as ardcode -- return NULL if no such 
103          * curve exists.
104          */
105     IpoCurve *icu;
106         
107         /* why this? (ton) */
108         if (!(key->ipo)) {
109                 key->ipo= add_ipo("KeyIpo", ID_KE);
110                 return NULL;
111         }
112
113     for (icu = key->ipo->curve.first; icu ; icu = icu->next) {
114         if (!icu->adrcode) continue;
115         if (icu->adrcode == keynum) return icu;
116     }
117
118     return NULL;
119 }
120
121 static BezTriple *get_bezt_icu_time(IpoCurve *icu, float *frame, float *val) {
122         /* this function tries to find a bezier that is within
123          * 0.25 time units from the specified frame. If there
124          * are more than one such beziers, it returns the
125          * closest one.
126          */
127         int   i;
128         float d, dmin = 0.25, newframe;
129         BezTriple *bezt = NULL;
130         
131         newframe = *frame;
132
133         for (i=0; i<icu->totvert; i++){
134                 d = fabs(icu->bezt[i].vec[1][0] - *frame);
135                 if (d < dmin) {
136                         dmin     = d;
137                         newframe = icu->bezt[i].vec[1][0];
138                         *val     = icu->bezt[i].vec[1][1];
139                         bezt     = icu->bezt + i;
140                 }
141         }
142
143         *frame = newframe;
144         return bezt;
145 }
146
147 static void rvk_slider_func(void *voidkey, void *voidkeynum) 
148 {
149         /* the callback for the rvk sliders ... copies the
150          * value from the temporary array into a bezier at the
151          * right frame on the right ipo curve (creating both the
152          * ipo curve and the bezier if needed).
153          */
154         IpoCurve  *icu=NULL;
155         BezTriple *bezt=NULL;
156         Key *key = (Key *) voidkey;
157         Object *ob= OBACT;
158         float cfra, rvkval;
159         int keynum = (int) voidkeynum;
160
161         cfra = frame_to_float(CFRA);
162
163         icu = verify_ipocurve(&key->id, ID_KE, NULL, NULL, keynum);
164
165         if (icu) {
166                 /* if the ipocurve exists, try to get a bezier
167                  * for this frame
168                  */
169                 bezt = get_bezt_icu_time(icu, &cfra, &rvkval);
170         }
171         
172         /* create the bezier triple if one doesn't exist,
173          * otherwise modify it's value
174          */
175         if (!bezt) {
176                 insert_vert_ipo(icu, cfra, meshslidervals[keynum]);
177         }
178         else {
179                 bezt->vec[1][1] = meshslidervals[keynum];
180         }
181
182         /* make sure the Ipo's are properly process and
183          * redraw as necessary
184          */
185         sort_time_ipocurve(icu);
186         testhandles_ipocurve(icu);
187
188         do_ipo(key->ipo);
189         
190         ob->shapeflag &= ~OB_SHAPE_TEMPLOCK;
191         DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
192         
193         allqueue (REDRAWVIEW3D, 0);
194         allqueue (REDRAWACTION, 0);
195         allqueue (REDRAWNLA, 0);
196         allqueue (REDRAWIPO, 0);
197         allspace(REMAKEIPO, 0);
198
199 }
200
201 static float getrvkval(Key *key, int keynum) 
202 {
203         /* get the value of the rvk from the
204          * ipo curve at the current time -- return 0
205          * if no ipo curve exists
206          */
207         IpoCurve  *icu=NULL;
208         BezTriple *bezt=NULL;
209         float     rvkval = 0.0;
210         float     cfra;
211
212         cfra = frame_to_float(CFRA);
213         icu    = get_key_icu(key, keynum);
214         if (icu) {
215                 bezt = get_bezt_icu_time(icu, &cfra, &rvkval);
216                 if (!bezt) {
217                         rvkval = eval_icu(icu, cfra);
218                 }
219         }
220
221         return rvkval;
222
223 }
224
225 void make_rvk_slider(uiBlock *block, Key *key, int keynum,
226                                          int x, int y, int w, int h, char *tip)
227 {
228         /* create a slider for the rvk */
229         uiBut         *but;
230         KeyBlock   *kb;
231         float min, max;
232         int i;
233         
234         /* global array */
235         meshslidervals[keynum] = getrvkval(key, keynum);
236
237         kb= key->block.first;
238         for (i=0; i<keynum; ++i) kb = kb->next; 
239
240         if ( (kb->slidermin >= kb->slidermax) ) {
241                 kb->slidermin = 0.0;
242                 kb->slidermax = 1.0;
243         }
244
245         min = (kb->slidermin < meshslidervals[keynum]) ? 
246                 kb->slidermin: meshslidervals[keynum];
247
248         max = (kb->slidermax > meshslidervals[keynum]) ? 
249                 kb->slidermax: meshslidervals[keynum];
250
251         but=uiDefButF(block, NUMSLI, REDRAWVIEW3D, "",
252                                   x, y , w, h,
253                                   meshslidervals+keynum, min, max, 10, 2, tip);
254         
255         uiButSetFunc(but, rvk_slider_func, key, (void *)keynum);
256         // no hilite, the winmatrix is not correct later on...
257         uiButSetFlag(but, UI_NO_HILITE);
258
259 }
260
261 static void default_key_ipo(Key *key)
262 {
263         IpoCurve *icu;
264         BezTriple *bezt;
265         
266         key->ipo= add_ipo("KeyIpo", ID_KE);
267         
268         icu= MEM_callocN(sizeof(IpoCurve), "ipocurve");
269                         
270         icu->blocktype= ID_KE;
271         icu->adrcode= KEY_SPEED;
272         icu->flag= IPO_VISIBLE|IPO_SELECT|IPO_AUTO_HORIZ;
273         set_icu_vars(icu);
274         
275         BLI_addtail( &(key->ipo->curve), icu);
276         
277         icu->bezt= bezt= MEM_callocN(2*sizeof(BezTriple), "defaultipo");
278         icu->totvert= 2;
279         
280         bezt->hide= IPO_BEZ;
281         bezt->f1=bezt->f2= bezt->f3= SELECT;
282         bezt->h1= bezt->h2= HD_AUTO;
283         bezt++;
284         bezt->vec[1][0]= 100.0;
285         bezt->vec[1][1]= 1.0;
286         bezt->hide= IPO_BEZ;
287         bezt->f1=bezt->f2= bezt->f3= SELECT;
288         bezt->h1= bezt->h2= HD_AUTO;
289         
290         calchandles_ipocurve(icu);
291 }
292
293         
294
295 /* **************************************** */
296
297 void mesh_to_key(Mesh *me, KeyBlock *kb)
298 {
299         MVert *mvert;
300         float *fp;
301         int a;
302         
303         if(me->totvert==0) return;
304         
305         if(kb->data) MEM_freeN(kb->data);
306         
307         kb->data= MEM_callocN(me->key->elemsize*me->totvert, "kb->data");
308         kb->totelem= me->totvert;
309         
310         mvert= me->mvert;
311         fp= kb->data;
312         for(a=0; a<kb->totelem; a++, fp+=3, mvert++) {
313                 VECCOPY(fp, mvert->co);
314                 
315         }
316 }
317
318 void key_to_mesh(KeyBlock *kb, Mesh *me)
319 {
320         MVert *mvert;
321         float *fp;
322         int a, tot;
323         
324         mvert= me->mvert;
325         fp= kb->data;
326         
327         tot= MIN2(kb->totelem, me->totvert);
328         
329         for(a=0; a<tot; a++, fp+=3, mvert++) {
330                 VECCOPY(mvert->co, fp);
331         }
332 }
333
334 static KeyBlock *add_keyblock(Key *key)
335 {
336         KeyBlock *kb;
337         float curpos= -0.1;
338         int tot;
339         
340         kb= key->block.last;
341         if(kb) curpos= kb->pos;
342         
343         kb= MEM_callocN(sizeof(KeyBlock), "Keyblock");
344         BLI_addtail(&key->block, kb);
345         kb->type= KEY_CARDINAL;
346         tot= BLI_countlist(&key->block);
347         if(tot==1) strcpy(kb->name, "Basis");
348         else sprintf(kb->name, "Key %d", tot-1);
349         kb->adrcode= tot-1;
350         
351         key->totkey++;
352         if(key->totkey==1) key->refkey= kb;
353         
354         
355         if(key->type == KEY_RELATIVE) 
356                 kb->pos= curpos+0.1;
357         else {
358                 curpos= bsystem_time(0, 0, (float)CFRA, 0.0);
359                 if(calc_ipo_spec(key->ipo, KEY_SPEED, &curpos)==0) {
360                         curpos /= 100.0;
361                 }
362                 kb->pos= curpos;
363                 
364                 sort_keys(key);
365         }
366         return kb;
367 }
368
369 void insert_meshkey(Mesh *me, short rel)
370 {
371         Key *key;
372         KeyBlock *kb;
373
374         if(me->key==NULL) {
375                 me->key= add_key( (ID *)me);
376
377                 if(rel)
378                         me->key->type = KEY_RELATIVE;
379                 else
380                         default_key_ipo(me->key);
381         }
382         key= me->key;
383         
384         kb= add_keyblock(key);
385         
386         mesh_to_key(me, kb);
387 }
388
389 /* ******************** */
390
391 void latt_to_key(Lattice *lt, KeyBlock *kb)
392 {
393         BPoint *bp;
394         float *fp;
395         int a, tot;
396         
397         tot= lt->pntsu*lt->pntsv*lt->pntsw;
398         if(tot==0) return;
399         
400         if(kb->data) MEM_freeN(kb->data);
401         
402         kb->data= MEM_callocN(lt->key->elemsize*tot, "kb->data");
403         kb->totelem= tot;
404         
405         bp= lt->def;
406         fp= kb->data;
407         for(a=0; a<kb->totelem; a++, fp+=3, bp++) {
408                 VECCOPY(fp, bp->vec);
409         }
410 }
411
412 void key_to_latt(KeyBlock *kb, Lattice *lt)
413 {
414         BPoint *bp;
415         float *fp;
416         int a, tot;
417         
418         bp= lt->def;
419         fp= kb->data;
420         
421         tot= lt->pntsu*lt->pntsv*lt->pntsw;
422         tot= MIN2(kb->totelem, tot);
423         
424         for(a=0; a<tot; a++, fp+=3, bp++) {
425                 VECCOPY(bp->vec, fp);
426         }
427         
428 }
429
430 /* exported to python... hrms, should not, use object levels! (ton) */
431 void insert_lattkey(Lattice *lt, short rel)
432 {
433         Key *key;
434         KeyBlock *kb;
435         
436         if(lt->key==NULL) {
437                 lt->key= add_key( (ID *)lt);
438                 default_key_ipo(lt->key);
439         }
440         key= lt->key;
441         
442         kb= add_keyblock(key);
443         
444         latt_to_key(lt, kb);
445 }
446
447 /* ******************************** */
448
449 void curve_to_key(Curve *cu, KeyBlock *kb, ListBase *nurb)
450 {
451         Nurb *nu;
452         BezTriple *bezt;
453         BPoint *bp;
454         float *fp;
455         int a, tot;
456         
457         /* count */
458         tot= count_curveverts(nurb);
459         if(tot==0) return;
460         
461         if(kb->data) MEM_freeN(kb->data);
462         
463         kb->data= MEM_callocN(cu->key->elemsize*tot, "kb->data");
464         kb->totelem= tot;
465         
466         nu= nurb->first;
467         fp= kb->data;
468         while(nu) {
469                 
470                 if(nu->bezt) {
471                         bezt= nu->bezt;
472                         a= nu->pntsu;
473                         while(a--) {
474                                 VECCOPY(fp, bezt->vec[0]);
475                                 fp+= 3;
476                                 VECCOPY(fp, bezt->vec[1]);
477                                 fp+= 3;
478                                 VECCOPY(fp, bezt->vec[2]);
479                                 fp+= 3;
480                                 fp[0]= bezt->alfa;
481                                 fp+= 3; /* alphas */
482                                 bezt++;
483                         }
484                 }
485                 else {
486                         bp= nu->bp;
487                         a= nu->pntsu*nu->pntsv;
488                         while(a--) {
489                                 VECCOPY(fp, bp->vec);
490                                 fp[3]= bp->alfa;
491                                 
492                                 fp+= 4;
493                                 bp++;
494                         }
495                 }
496                 nu= nu->next;
497         }
498 }
499
500 void key_to_curve(KeyBlock *kb, Curve  *cu, ListBase *nurb)
501 {
502         Nurb *nu;
503         BezTriple *bezt;
504         BPoint *bp;
505         float *fp;
506         int a, tot;
507         
508         nu= nurb->first;
509         fp= kb->data;
510         
511         tot= count_curveverts(nurb);
512
513         tot= MIN2(kb->totelem, tot);
514         
515         while(nu && tot>0) {
516                 
517                 if(nu->bezt) {
518                         bezt= nu->bezt;
519                         a= nu->pntsu;
520                         while(a-- && tot>0) {
521                                 VECCOPY(bezt->vec[0], fp);
522                                 fp+= 3;
523                                 VECCOPY(bezt->vec[1], fp);
524                                 fp+= 3;
525                                 VECCOPY(bezt->vec[2], fp);
526                                 fp+= 3;
527                                 bezt->alfa= fp[0];
528                                 fp+= 3; /* alphas */
529                         
530                                 tot-= 3;
531                                 bezt++;
532                         }
533                 }
534                 else {
535                         bp= nu->bp;
536                         a= nu->pntsu*nu->pntsv;
537                         while(a-- && tot>0) {
538                                 VECCOPY(bp->vec, fp);
539                                 bp->alfa= fp[3];
540                                 
541                                 fp+= 4;
542                                 tot--;
543                                 bp++;
544                         }
545                 }
546                 nu= nu->next;
547         }
548 }
549
550
551 void insert_curvekey(Curve *cu, short rel) 
552 {
553         Key *key;
554         KeyBlock *kb;
555         
556         if(cu->key==NULL) {
557                 cu->key= add_key( (ID *)cu);
558
559                 if (rel)
560                         cu->key->type = KEY_RELATIVE;
561                 else
562                         default_key_ipo(cu->key);
563         }
564         key= cu->key;
565         
566         kb= add_keyblock(key);
567         
568         if(editNurb.first) curve_to_key(cu, kb, &editNurb);
569         else curve_to_key(cu, kb, &cu->nurb);
570 }
571
572
573 /* ******************** */
574
575 void insert_shapekey(Object *ob)
576 {
577         Key *key;
578         
579         if(ob->type==OB_MESH) insert_meshkey(ob->data, 1);
580         else if ELEM(ob->type, OB_CURVE, OB_SURF) insert_curvekey(ob->data, 1);
581         else if(ob->type==OB_LATTICE) insert_lattkey(ob->data, 1);
582         
583         key= ob_get_key(ob);
584         ob->shapenr= BLI_countlist(&key->block);
585         
586         allspace(REMAKEIPO, 0);
587         allqueue(REDRAWIPO, 0);
588         allqueue(REDRAWACTION, 0);
589         allqueue(REDRAWNLA, 0);
590         allqueue(REDRAWBUTSOBJECT, 0);
591         allqueue(REDRAWBUTSEDIT, 0);
592 }
593
594 void delete_key(Object *ob)
595 {
596         KeyBlock *kb;
597         Key *key;
598         IpoCurve *icu;
599         
600         key= ob_get_key(ob);
601         if(key==NULL) return;
602         
603         kb= BLI_findlink(&key->block, ob->shapenr-1);
604
605         if(kb) {
606                 BLI_remlink(&key->block, kb);
607                 key->totkey--;
608                 if(key->refkey== kb) key->refkey= key->block.first;
609                         
610                 if(kb->data) MEM_freeN(kb->data);
611                 MEM_freeN(kb);
612                 
613                 for(kb= key->block.first; kb; kb= kb->next) {
614                         if(kb->adrcode>=ob->shapenr)
615                                 kb->adrcode--;
616                 }
617                 
618                 if(key->ipo) {
619                         for(icu= key->ipo->curve.first; icu; icu= icu->next) {
620                                 if(icu->adrcode==ob->shapenr-1) {
621                                         BLI_remlink(&key->ipo->curve, icu);
622                                         if(icu->bezt) MEM_freeN(icu->bezt);
623                                         MEM_freeN(icu);
624                                         break;
625                                 }
626                         }
627                         for(icu= key->ipo->curve.first; icu; icu= icu->next) 
628                                 if(icu->adrcode>=ob->shapenr)
629                                         icu->adrcode--;
630                 }               
631                 
632                 if(ob->shapenr>1) ob->shapenr--;
633         }
634         
635         if(key->totkey==0) {
636                 if(GS(key->from->name)==ID_ME) ((Mesh *)key->from)->key= NULL;
637                 else if(GS(key->from->name)==ID_CU) ((Curve *)key->from)->key= NULL;
638                 else if(GS(key->from->name)==ID_LT) ((Lattice *)key->from)->key= NULL;
639
640                 free_libblock_us(&(G.main->key), key);
641                 scrarea_queue_headredraw(curarea);      /* ipo remove too */
642         }
643         
644         DAG_object_flush_update(G.scene, OBACT, OB_RECALC_DATA);
645         
646         allqueue(REDRAWVIEW3D, 0);
647         allqueue(REDRAWBUTSEDIT, 0);
648         allspace(REMAKEIPO, 0);
649         allqueue(REDRAWIPO, 0);
650 }
651
652 void move_keys(Object *ob)
653 {
654         Key *key;
655         KeyBlock *kb;
656         float div, dy, oldpos, vec[3], dvec[3];
657         int afbreek=0, firsttime= 1;
658         unsigned short event = 0;
659         short mval[2], val, xo, yo;
660         char str[32];
661         
662         if(G.sipo->blocktype!=ID_KE) return;
663         
664         if(G.sipo->ipo && G.sipo->ipo->id.lib) return;
665         if(G.sipo->editipo==NULL) return;
666
667         key= (Key *)G.sipo->from;
668         if(key==NULL) return;
669         
670         /* which kb is involved */
671         kb= BLI_findlink(&key->block, ob->shapenr-1);
672         if(kb==NULL) return;    
673         
674         oldpos= kb->pos;
675         
676         getmouseco_areawin(mval);
677         xo= mval[0];
678         yo= mval[1];
679         dvec[0]=dvec[1]=dvec[2]= 0.0; 
680
681         while(afbreek==0) {
682                 getmouseco_areawin(mval);
683                 if(mval[0]!=xo || mval[1]!=yo || firsttime) {
684                         firsttime= 0;
685                         
686                         dy= (float)(mval[1]- yo);
687
688                         div= (float)(G.v2d->mask.ymax-G.v2d->mask.ymin);
689                         dvec[1]+= (G.v2d->cur.ymax-G.v2d->cur.ymin)*(dy)/div;
690                         
691                         VECCOPY(vec, dvec);
692
693                         apply_keyb_grid(vec, 0.0, 1.0, 0.1, U.flag & USER_AUTOGRABGRID);
694                         apply_keyb_grid(vec+1, 0.0, 1.0, 0.1, U.flag & USER_AUTOGRABGRID);
695
696                         kb->pos= oldpos+vec[1];
697                         
698                         sprintf(str, "Y: %.3f  ", vec[1]);
699                         headerprint(str);
700                         
701                         xo= mval[0];
702                         yo= mval[1];
703                                 
704                         force_draw(0);
705                 }
706                 else BIF_wait_for_statechange();
707                 
708                 while(qtest()) {
709                         event= extern_qread(&val);
710                         if(val) {
711                                 switch(event) {
712                                 case ESCKEY:
713                                 case LEFTMOUSE:
714                                 case SPACEKEY:
715                                         afbreek= 1;
716                                         break;
717                                 default:
718                                         arrows_move_cursor(event);
719                                 }
720                         }
721                 }
722         }
723         
724         if(event==ESCKEY) {
725                 kb->pos= oldpos;
726         }
727         
728         sort_keys(key);
729         DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
730         
731         /* for boundbox */
732         editipo_changed(G.sipo, 0);
733
734         allspace(REMAKEIPO, 0);
735         allqueue(REDRAWIPO, 0);
736         allqueue(REDRAWVIEW3D, 0);
737         allqueue(REDRAWBUTSEDIT, 0);
738         scrarea_queue_redraw(curarea);
739 }