=== Custom Transform Orientation ===
[blender.git] / source / blender / src / drawtime.c
1 /**
2  * $Id:
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2005 Blender Foundation.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <math.h>
31 #include <stdio.h>
32 #include <string.h>
33
34 #ifdef HAVE_CONFIG_H
35 #include <config.h>
36 #endif
37
38 #include "BLI_blenlib.h"
39 #include "BLI_arithb.h"
40
41 #include "DNA_action_types.h"
42 #include "DNA_ipo_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_material_types.h"
45 #include "DNA_scene_types.h"
46 #include "DNA_space_types.h"
47 #include "DNA_screen_types.h"
48 #include "DNA_sound_types.h"
49 #include "DNA_view2d_types.h"
50
51 #include "BKE_ipo.h"
52 #include "BKE_object.h"
53 #include "BKE_material.h"
54 #include "BKE_utildefines.h"
55 #include "BKE_global.h"
56
57 #include "BIF_editaction.h"
58 #include "BIF_gl.h"
59 #include "BIF_interface.h"
60 #include "BIF_interface_icons.h"
61 #include "BIF_mywindow.h"
62 #include "BIF_screen.h"
63 #include "BIF_resources.h"
64 #include "BIF_language.h"
65
66 #include "BSE_drawipo.h"
67 #include "BSE_time.h"
68 #include "BSE_view.h"
69
70 #include "blendef.h"
71 #include "interface.h"  /* for ui_rasterpos_safe */
72
73 #define TIMELINE_STIPPLE \
74 { \
75         136,136,136,136,0,0,0,0,34,34,34,34,0,0,0,0, \
76         136,136,136,136,0,0,0,0,34,34,34,34,0,0,0,0, \
77         136,136,136,136,0,0,0,0,34,34,34,34,0,0,0,0, \
78         136,136,136,136,0,0,0,0,34,34,34,34,0,0,0,0, \
79         136,136,136,136,0,0,0,0,34,34,34,34,0,0,0,0, \
80         136,136,136,136,0,0,0,0,34,34,34,34,0,0,0,0, \
81         136,136,136,136,0,0,0,0,34,34,34,34,0,0,0,0, \
82         136,136,136,136,0,0,0,0,34,34,34,34,0,0,0,0 \
83 }
84
85 /* ---- prototypes ------ */
86 void drawtimespace(ScrArea *, void *);
87
88 /* draws a current frame indicator for the TimeLine */
89 static void draw_cfra_time(SpaceTime *stime)
90 {
91         float vec[2];
92         
93         vec[0]=  (G.scene->r.cfra);
94         vec[0]*= G.scene->r.framelen;
95
96         vec[1]= G.v2d->cur.ymin;
97         BIF_ThemeColor(TH_CFRAME);      // no theme, should be global color once...
98         glLineWidth(3.0);
99
100         glBegin(GL_LINES);
101                 glVertex2fv(vec);
102                 vec[1]= G.v2d->cur.ymax;
103                 glVertex2fv(vec);
104         glEnd();
105         
106         glLineWidth(1.0);
107         
108         if(stime->flag & TIME_CFRA_NUM) {
109                 short mval[2];
110                 float x,  y;
111                 float xscale, yscale;
112                 char str[32];
113                 
114                 /* little box with frame drawn beside */
115                 
116                 glFlush();      // huhh... without this glColor won't work for the text...
117                 getmouseco_areawin(mval);
118                 
119                 if(mval[1]>curarea->winy-10) mval[1]= curarea->winy - 13;
120                 
121                 if (curarea->winy < 25) {       
122                         if (mval[1]<17) mval[1]= 17;
123                 } else if (mval[1]<22) mval[1]= 22;
124                 
125                 areamouseco_to_ipoco(G.v2d, mval, &x, &y);
126                 
127                 if(stime->flag & TIME_DRAWFRAMES) 
128                         sprintf(str, "   %d", CFRA);
129                 else sprintf(str, "   %.2f", FRA2TIME(CFRA));
130                 
131                 /* HACK! somehow the green color won't go away... */
132                 glColor4ub(0, 0, 0, 0);
133                 BIF_ThemeColor(TH_TEXT);
134                 
135                 xscale = (G.v2d->mask.xmax-G.v2d->mask.xmin)/(G.v2d->cur.xmax-G.v2d->cur.xmin);
136                 yscale = (G.v2d->mask.ymax-G.v2d->mask.ymin)/(G.v2d->cur.ymax-G.v2d->cur.ymin);
137                 
138                 /* because the frame number text is subject to the same scaling as the contents of the view */
139                 glScalef( 1.0/xscale, 1.0/yscale, 1.0);
140                 
141                 ui_rasterpos_safe(x * xscale, y * yscale, 1.0);
142                 BIF_DrawString(G.fonts, str, 0);
143                 glScalef(xscale, yscale, 1.0);
144         }
145         
146 }
147
148 /* ---------- */
149
150 /* function to draw markers */
151 static void draw_marker(TimeMarker *marker, int flag)
152 {
153         float xpos, ypixels, xscale, yscale;
154         int icon_id= 0;
155
156         xpos = marker->frame;
157         /* no time correction for framelen! space is drawn with old values */
158         
159         ypixels= G.v2d->mask.ymax-G.v2d->mask.ymin;
160         xscale = (G.v2d->mask.xmax-G.v2d->mask.xmin)/(G.v2d->cur.xmax-G.v2d->cur.xmin);
161         yscale = (G.v2d->mask.ymax-G.v2d->mask.ymin)/(G.v2d->cur.ymax-G.v2d->cur.ymin);
162
163         glScalef( 1.0/xscale, 1.0/yscale, 1.0);
164         
165         glEnable(GL_BLEND);
166         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);                      
167         
168         /* verticle line */
169         if (flag & DRAW_MARKERS_LINES) {
170                 setlinestyle(3);
171                 if(marker->flag & SELECT)
172                         glColor4ub(255,255,255, 96);
173                 else
174                         glColor4ub(0,0,0, 96);
175                 
176                 glBegin(GL_LINES);
177                 glVertex2f((xpos*xscale)+0.5, 12);
178                 glVertex2f((xpos*xscale)+0.5, 34*yscale); /* a bit lazy but we know it cant be greater then 34 strips high*/
179                 glEnd();
180                 setlinestyle(0);
181         }
182         
183         /* 5 px to offset icon to align properly, space / pixels corrects for zoom */
184         if (flag & DRAW_MARKERS_LOCAL) {
185                 icon_id= (marker->flag & ACTIVE) ? ICON_PMARKER_ACT : 
186                                  (marker->flag & SELECT) ? ICON_PMARKER_SEL : 
187                                  ICON_PMARKER;
188         }
189         else {
190                 icon_id= (marker->flag & SELECT) ? ICON_MARKER_HLT : 
191                                  ICON_MARKER;
192         }
193         BIF_icon_draw(xpos*xscale-5.0, 12.0, icon_id);
194         
195         glBlendFunc(GL_ONE, GL_ZERO);
196         glDisable(GL_BLEND);
197                 
198         /* and the marker name too, shifted slightly to the top-right */
199         if(marker->name && marker->name[0]) {
200                 if(marker->flag & SELECT) {
201                         BIF_ThemeColor(TH_TEXT_HI);
202                         ui_rasterpos_safe(xpos*xscale+4.0, (ypixels<=39.0)?(ypixels-10.0):29.0, 1.0);
203                 }
204                 else {
205                         BIF_ThemeColor(TH_TEXT);
206                         if((marker->frame <= G.scene->r.cfra) && (marker->frame+5 > G.scene->r.cfra))
207                                 ui_rasterpos_safe(xpos*xscale+4.0, (ypixels<=39.0)?(ypixels-10.0):29.0, 1.0);
208                         else
209                                 ui_rasterpos_safe(xpos*xscale+4.0, 17.0, 1.0);
210                 }
211                 BIF_DrawString(G.font, marker->name, 0);
212         }
213         glScalef(xscale, yscale, 1.0);
214 }
215
216 /* Draw Scene-Markers for the TimeLine */
217 static void draw_markers_time(int flag)
218 {
219         TimeMarker *marker;
220
221         /* unselected markers are drawn at the first time */
222         for (marker= G.scene->markers.first; marker; marker= marker->next) {
223                 if (!(marker->flag & SELECT)) draw_marker(marker, flag);
224         }
225
226         /* selected markers are drawn later ... selected markers have to cover unselected
227          * markers laying at the same position as selected markers
228          * (jiri: it is hack, it could be solved better) 
229          */
230         for (marker= G.scene->markers.first; marker; marker= marker->next) {
231                 if (marker->flag & SELECT) draw_marker(marker, flag);
232         }
233 }
234
235 /* Draw specified set of markers for Animation Editors */
236 void draw_markers_timespace(ListBase *markers, int flag)
237 {
238         TimeMarker *marker;
239         float yspace, ypixels;
240         
241         /* move ortho view to align with slider in bottom */
242         glTranslatef(0.0f, G.v2d->cur.ymin, 0.0f);
243         
244         /* bad hacks in drawing markers... inverse correct that as well */
245         yspace= G.v2d->cur.ymax - G.v2d->cur.ymin;
246         ypixels= G.v2d->mask.ymax - G.v2d->mask.ymin;
247         glTranslatef(0.0f, -11.0*yspace/ypixels, 0.0f);
248                 
249         /* unselected markers are drawn at the first time */
250         for (marker= markers->first; marker; marker= marker->next) {
251                 if (!(marker->flag & SELECT)) draw_marker(marker, flag);
252         }
253         
254         /* selected markers are drawn later ... selected markers have to cover unselected
255                 * markers laying at the same position as selected markers */
256         for (marker= markers->first; marker; marker= marker->next) {
257                 if (marker->flag & SELECT) draw_marker(marker, flag);
258         }
259
260         glTranslatef(0.0f, -G.v2d->cur.ymin, 0.0f);
261         glTranslatef(0.0f, 11.0*yspace/ypixels, 0.0f);
262 }
263
264
265 void draw_anim_preview_timespace()
266 {
267         /* only draw this if preview range is set */
268         if (G.scene->r.psfra) {
269                 glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
270                 glEnable(GL_BLEND);
271                 glColor4f(0, 0, 0, 0.4);
272         
273                 if (PSFRA < PEFRA) {
274                         glRectf(G.v2d->cur.xmin, G.v2d->cur.ymin, PSFRA, G.v2d->cur.ymax);
275                         glRectf(PEFRA, G.v2d->cur.ymin, G.v2d->cur.xmax, G.v2d->cur.ymax);      
276                 } 
277                 else {
278                         glRectf(G.v2d->cur.xmin, G.v2d->cur.ymin, G.v2d->cur.xmax, G.v2d->cur.ymax);
279                 }
280                 
281                 glDisable(GL_BLEND);
282         }
283 }
284
285 static void draw_sfra_efra()
286 {
287         BIF_ThemeColorShade(TH_BACK, -25);
288         
289         if (PSFRA < PEFRA) {
290                 glRectf(G.v2d->cur.xmin, G.v2d->cur.ymin, PSFRA, G.v2d->cur.ymax);
291                 glRectf(PEFRA, G.v2d->cur.ymin, G.v2d->cur.xmax, G.v2d->cur.ymax);      
292         } 
293         else {
294                 glRectf(G.v2d->cur.xmin, G.v2d->cur.ymin, G.v2d->cur.xmax, G.v2d->cur.ymax);
295         }
296         
297         BIF_ThemeColorShade(TH_BACK, -60);
298         /* thin lines where the actual frames are */
299         fdrawline(PSFRA, G.v2d->cur.ymin, PSFRA, G.v2d->cur.ymax);
300         fdrawline(PEFRA, G.v2d->cur.ymin, PEFRA, G.v2d->cur.ymax);
301         
302         glDisable(GL_BLEND);
303 }
304
305 static void draw_mapoldnew()
306 {
307         float anim_end; /* the end of the blender frames that are actually animated (map old)*/
308         float frames_end;       /* the end of the frames that get rendered and saved to disk (map new) */
309         GLubyte timeline_stipple[32*32/8] = TIMELINE_STIPPLE;
310         
311         if (G.scene->r.framelen == 1.0) return;
312         
313         anim_end = PEFRA * G.scene->r.framelen;
314         frames_end = PEFRA;
315         
316         glEnable(GL_POLYGON_STIPPLE);
317         glPolygonStipple(timeline_stipple);
318         BIF_ThemeColorShade(TH_BACK, -65);
319         
320         if (anim_end < frames_end)
321                 glRectf(anim_end, G.v2d->cur.ymin, frames_end, G.v2d->cur.ymax);
322
323         glDisable(GL_POLYGON_STIPPLE);
324 }
325
326 /*draw all the keys in a list (elems) as lines */
327 static void draw_key_list(ListBase elems, char col[3]) 
328 {
329         CfraElem *ce;
330         float drawframe;
331
332         ce= elems.first;
333         while(ce) {
334                 drawframe = ce->cfra; //not correct for G.scene->r.framelen;
335                 glColor3ub(col[0], col[1], col[2]);
336
337                 fdrawline(drawframe, G.v2d->cur.ymin, drawframe, G.v2d->cur.ymax);
338                 
339                 ce= ce->next;
340         }
341 }
342
343 /* This function draws keyframes that the active object has (as long as
344  * it is not in EditMode). Some filters are available to optimise the
345  * drawing efficiency.
346  */
347 static void draw_ob_keys()
348 {
349         /* mostly copied from drawobject.c, draw_object() */
350         SpaceTime *stime= curarea->spacedata.first;
351         ListBase elems= {0, 0};
352         
353         Object *ob= OBACT;
354         short filter, ok;
355         char col[3];
356         int a;
357
358         if (ob && ob!=G.obedit) {
359                 /* Object's IPO block - show all keys */
360                 if (ob->ipo) {
361                         /* convert the ipo to a list of 'current frame elements' */
362                         elems.first= elems.last= NULL;
363                         make_cfra_list(ob->ipo, &elems);
364                         
365                         /* draw the list of current frame elements */
366                         col[0] = 0xDD; col[1] = 0xD7; col[2] = 0x00;
367                         draw_key_list(elems, col);
368                         
369                         BLI_freelistN(&elems);
370                 }
371                 
372                 /* Object's Action block - may be filtered in some cases */
373                 if (ob->action) {
374                         bAction *act = ob->action;
375                         bActionChannel *achan;
376                         
377                         /* only apply filter if action is likely to be for pose channels + filter is on */
378                         filter= ((stime->flag & TIME_ONLYACTSEL) && 
379                                          (ob->pose) && (ob->flag & OB_POSEMODE));
380                         
381                         /* go through each channel in the action */
382                         for (achan=act->chanbase.first; achan; achan=achan->next) {
383                                 /* if filtering, check if this channel passes */
384                                 if (filter) {
385                                         ok= (SEL_ACHAN(achan))? 1 : 0;
386                                 }
387                                 else ok= 1;
388                                 
389                                 /* convert the ipo to a list of 'current frame elements' */
390                                 if (achan->ipo && ok) {
391                                         elems.first= elems.last= NULL;
392                                         make_cfra_list(achan->ipo, &elems);
393                                         
394                                         col[0] = 0x00; col[1] = 0x82; col[2] = 0x8B;
395                                         draw_key_list(elems, col);
396                                         
397                                         BLI_freelistN(&elems);
398                                 }
399                         }
400                 }
401                 
402                 /* Materials (only relevant for geometry objects) - some filtering might occur */
403                 filter= (stime->flag & TIME_ONLYACTSEL);
404                 for (a=0; a<ob->totcol; a++) {
405                         Material *ma= give_current_material(ob, a+1);
406                         
407                         /* the only filter we apply right now is only showing the active material */
408                         if (filter) {
409                                 ok= (ob->actcol==a)? 1 : 0;
410                         }
411                         else ok= 1;
412                         
413                         if (ma && ma->ipo && ok) {
414                                 elems.first= elems.last= NULL;
415                                 make_cfra_list(ma->ipo, &elems);
416                                 
417                                 col[0] = 0xDD; col[1] = 0xA7; col[2] = 0x00;
418                                 draw_key_list(elems, col);
419                                 
420                                 BLI_freelistN(&elems);
421                         }
422                 }
423         }
424 }
425
426 void drawtimespace(ScrArea *sa, void *spacedata)
427 {
428         SpaceTime *stime= sa->spacedata.first;
429         float col[3];
430         
431         BIF_GetThemeColor3fv(TH_BACK, col);
432         glClearColor(col[0], col[1], col[2], 0.0);
433         glClear(GL_COLOR_BUFFER_BIT);
434
435         calc_scrollrcts(sa, &(stime->v2d), curarea->winx, curarea->winy);
436         
437         myortho2(stime->v2d.cur.xmin, stime->v2d.cur.xmax, stime->v2d.cur.ymin, stime->v2d.cur.ymax);
438
439         /* draw darkened area outside of active timeline 
440          *      frame range used is preview range or scene range
441          */
442         draw_sfra_efra();
443         draw_mapoldnew();
444         
445         /* boundbox_seq(); */
446         calc_ipogrid(); 
447         draw_ipogrid();
448
449         draw_cfra_time(spacedata);
450         draw_ob_keys();
451         draw_markers_time(0);
452
453         /* restore viewport */
454         mywinset(curarea->win);
455
456         /* ortho at pixel level curarea */
457         myortho2(-0.375, curarea->winx-0.375, -0.375, curarea->winy-0.375);
458         
459         /* the bottom with time values */
460         BIF_ThemeColor(TH_HEADER);
461         glRectf(0.0f, 0.0f, (float)curarea->winx, 12.0f);
462         BIF_ThemeColorShade(TH_HEADER, 50);
463         fdrawline(0.0f, 12.0f, (float)curarea->winx, 12.0f);
464         draw_view2d_numbers_horiz(stime->flag & TIME_DRAWFRAMES);
465         
466         draw_area_emboss(sa);
467         curarea->win_swap= WIN_BACK_OK;
468 }