279e6ce04001104d115af209bd0bc6b4aaf0f2c6
[blender.git] / source / blender / editors / space_graph / graph_draw.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  * The Original Code is Copyright (C) Blender Foundation
19  *
20  * Contributor(s): Joshua Leung (2009 Recode)
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/space_graph/graph_draw.c
26  *  \ingroup spgraph
27  */
28
29
30 #include <stdio.h>
31 #include <math.h>
32 #include <string.h>
33 #include <float.h>
34
35 #ifndef _WIN32
36 #include <unistd.h>
37 #else
38 #include <io.h>
39 #endif
40
41
42 #include "BLI_blenlib.h"
43 #include "BLI_math.h"
44 #include "BLI_utildefines.h"
45
46 #include "DNA_anim_types.h"
47 #include "DNA_object_types.h"
48 #include "DNA_screen_types.h"
49 #include "DNA_space_types.h"
50 #include "DNA_windowmanager_types.h"
51 #include "DNA_userdef_types.h"
52
53 #include "BKE_context.h"
54 #include "BKE_curve.h"
55 #include "BKE_fcurve.h"
56
57
58 #include "BIF_gl.h"
59 #include "BIF_glutil.h"
60
61 #include "ED_anim_api.h"
62
63 #include "graph_intern.h"
64
65 #include "UI_interface.h"
66 #include "UI_resources.h"
67 #include "UI_view2d.h"
68
69 /* *************************** */
70 /* Utility Drawing Defines */
71
72 /* determine the alpha value that should be used when 
73  * drawing components for some F-Curve (fcu)
74  *      - selected F-Curves should be more visible than partially visible ones
75  */
76 #define drawFCurveFade(fcu) ( ((fcu)->flag & FCURVE_SELECTED)? 1.0f : U.fcu_inactive_alpha )
77
78 /* set the color for some point from some value given packed into an int 
79  *      - intV: integer value containing color info packed into an int
80  *      - alpha: float value describing the 
81  */
82 #define cpackA(intVC, alpha)                                                  \
83         {                                                                         \
84                 float _cpackCol[3];                                                   \
85                 cpack_to_rgb(intVC, &_cpackCol[0], &_cpackCol[1], &_cpackCol[2]);     \
86                 glColor4f(_cpackCol[0], _cpackCol[1], _cpackCol[2], alpha);           \
87         }
88
89 /* *************************** */
90 /* F-Curve Modifier Drawing */
91
92 /* Envelope -------------- */
93
94 // TODO: draw a shaded poly showing the region of influence too!!!
95 static void draw_fcurve_modifier_controls_envelope (FModifier *fcm, View2D *v2d)
96 {
97         FMod_Envelope *env= (FMod_Envelope *)fcm->data;
98         FCM_EnvelopeData *fed;
99         const float fac= 0.05f * (v2d->cur.xmax - v2d->cur.xmin);
100         int i;
101         
102         /* draw two black lines showing the standard reference levels */
103         glColor3f(0.0f, 0.0f, 0.0f);
104         setlinestyle(5);
105         
106         glBegin(GL_LINES);
107                 glVertex2f(v2d->cur.xmin, env->midval+env->min);
108                 glVertex2f(v2d->cur.xmax, env->midval+env->min);
109                 
110                 glVertex2f(v2d->cur.xmin, env->midval+env->max);
111                 glVertex2f(v2d->cur.xmax, env->midval+env->max);
112         glEnd(); // GL_LINES
113         setlinestyle(0);
114         
115         /* set size of vertices (non-adjustable for now) */
116         glPointSize(2.0f);
117         
118         // for now, point color is fixed, and is white
119         glColor3f(1.0f, 1.0f, 1.0f);
120         
121         /* we use bgl points not standard gl points, to workaround vertex 
122          * drawing bugs that some drivers have (probably legacy ones only though)
123          */
124         bglBegin(GL_POINTS);
125         for (i=0, fed=env->data; i < env->totvert; i++, fed++) {
126                 /* only draw if visible
127                  *      - min/max here are fixed, not relative
128                  */
129                 if IN_RANGE(fed->time, (v2d->cur.xmin - fac), (v2d->cur.xmax + fac)) {
130                         glVertex2f(fed->time, fed->min);
131                         glVertex2f(fed->time, fed->max);
132                 }
133         }
134         bglEnd(); // GL_POINTS
135         
136         glPointSize(1.0f);
137 }
138
139 /* *************************** */
140 /* F-Curve Drawing */
141
142 /* Points ---------------- */
143
144 /* helper func - draw keyframe vertices only for an F-Curve */
145 static void draw_fcurve_vertices_keyframes (FCurve *fcu, SpaceIpo *UNUSED(sipo), View2D *v2d, short edit, short sel)
146 {
147         BezTriple *bezt= fcu->bezt;
148         const float fac= 0.05f * (v2d->cur.xmax - v2d->cur.xmin);
149         int i;
150         
151         /* we use bgl points not standard gl points, to workaround vertex 
152          * drawing bugs that some drivers have (probably legacy ones only though)
153          */
154         bglBegin(GL_POINTS);
155         
156         for (i = 0; i < fcu->totvert; i++, bezt++) {
157                 /* as an optimization step, only draw those in view 
158                  *      - we apply a correction factor to ensure that points don't pop in/out due to slight twitches of view size
159                  */
160                 if IN_RANGE(bezt->vec[1][0], (v2d->cur.xmin - fac), (v2d->cur.xmax + fac)) {
161                         if (edit) {
162                                 /* 'Keyframe' vertex only, as handle lines and handles have already been drawn
163                                  *      - only draw those with correct selection state for the current drawing color
164                                  *      - 
165                                  */
166                                 if ((bezt->f2 & SELECT) == sel)
167                                         bglVertex3fv(bezt->vec[1]);
168                         }
169                         else {
170                                 /* no check for selection here, as curve is not editable... */
171                                 // XXX perhaps we don't want to even draw points?   maybe add an option for that later
172                                 bglVertex3fv(bezt->vec[1]);
173                         }
174                 }
175         }
176         
177         bglEnd(); // GL_POINTS
178 }
179
180
181 /* helper func - draw handle vertex for an F-Curve as a round unfilled circle 
182  * NOTE: the caller MUST HAVE GL_LINE_SMOOTH & GL_BLEND ENABLED, otherwise, the controls don't 
183  * have a consistent appearance (due to off-pixel alignments)...
184  */
185 static void draw_fcurve_handle_control (float x, float y, float xscale, float yscale, float hsize)
186 {
187         static GLuint displist=0;
188         
189         /* initialize round circle shape */
190         if (displist == 0) {
191                 GLUquadricObj *qobj;
192                 
193                 displist= glGenLists(1);
194                 glNewList(displist, GL_COMPILE);
195                 
196                 qobj    = gluNewQuadric(); 
197                 gluQuadricDrawStyle(qobj, GLU_SILHOUETTE); 
198                 gluDisk(qobj, 0,  0.7, 8, 1);
199                 gluDeleteQuadric(qobj);  
200                 
201                 glEndList();
202         }
203         
204         /* adjust view transform before starting */
205         glTranslatef(x, y, 0.0f);
206         glScalef(1.0f/xscale*hsize, 1.0f/yscale*hsize, 1.0f);
207         
208         /* draw! */
209         glCallList(displist);
210         
211         /* restore view transform */
212         glScalef(xscale/hsize, yscale/hsize, 1.0);
213         glTranslatef(-x, -y, 0.0f);
214 }
215
216 /* helper func - draw handle vertices only for an F-Curve (if it is not protected) */
217 static void draw_fcurve_vertices_handles (FCurve *fcu, SpaceIpo *sipo, View2D *v2d, short sel, short sel_handle_only)
218 {
219         BezTriple *bezt= fcu->bezt;
220         BezTriple *prevbezt = NULL;
221         float hsize, xscale, yscale;
222         int i;
223         
224         /* get view settings */
225         hsize= UI_GetThemeValuef(TH_HANDLE_VERTEX_SIZE);
226         UI_view2d_getscale(v2d, &xscale, &yscale);
227         
228         /* set handle color */
229         if (sel) UI_ThemeColor(TH_HANDLE_VERTEX_SELECT);
230         else UI_ThemeColor(TH_HANDLE_VERTEX);
231         
232         /* anti-aliased lines for more consistent appearance */
233         if ((sipo->flag & SIPO_BEAUTYDRAW_OFF)==0) glEnable(GL_LINE_SMOOTH);
234         glEnable(GL_BLEND);
235         
236         for (i=0; i < fcu->totvert; i++, prevbezt=bezt, bezt++) {
237                 /* Draw the editmode handles for a bezier curve (others don't have handles) 
238                  * if their selection status matches the selection status we're drawing for
239                  *      - first handle only if previous beztriple was bezier-mode
240                  *      - second handle only if current beztriple is bezier-mode
241                  *
242                  * Also, need to take into account whether the keyframe was selected
243                  * if a Graph Editor option to only show handles of selected keys is on.
244                  */
245                 if ( !sel_handle_only || BEZSELECTED(bezt) ) {
246                         if ( (!prevbezt && (bezt->ipo==BEZT_IPO_BEZ)) || (prevbezt && (prevbezt->ipo==BEZT_IPO_BEZ)) ) {
247                                 if ((bezt->f1 & SELECT) == sel)/* && v2d->cur.xmin < bezt->vec[0][0] < v2d->cur.xmax)*/
248                                         draw_fcurve_handle_control(bezt->vec[0][0], bezt->vec[0][1], xscale, yscale, hsize);
249                         }
250                         
251                         if (bezt->ipo==BEZT_IPO_BEZ) {
252                                 if ((bezt->f3 & SELECT) == sel)/* && v2d->cur.xmin < bezt->vec[2][0] < v2d->cur.xmax)*/
253                                         draw_fcurve_handle_control(bezt->vec[2][0], bezt->vec[2][1], xscale, yscale, hsize);
254                         }
255                 }
256         }
257         
258         if ((sipo->flag & SIPO_BEAUTYDRAW_OFF)==0) glDisable(GL_LINE_SMOOTH);
259         glDisable(GL_BLEND);
260 }
261
262 /* helper func - set color to draw F-Curve data with */
263 static void set_fcurve_vertex_color (FCurve *fcu, short sel)
264 {
265         /* Fade the 'intensity' of the vertices based on the selection of the curves too */
266         int alphaOffset= (int)((drawFCurveFade(fcu) - 1.0f) * 255);
267         
268         /* Set color of curve vertex based on state of curve (i.e. 'Edit' Mode) */
269         if ((fcu->flag & FCURVE_PROTECTED)==0) {
270                 /* Curve's points ARE BEING edited */
271                 if (sel) UI_ThemeColorShadeAlpha(TH_VERTEX_SELECT, 0, alphaOffset); 
272                 else UI_ThemeColorShadeAlpha(TH_VERTEX, 0, alphaOffset);
273         } 
274         else {
275                 /* Curve's points CANNOT BE edited */
276                 if (sel) UI_ThemeColorShadeAlpha(TH_TEXT_HI, 0, alphaOffset);
277                 else UI_ThemeColorShadeAlpha(TH_TEXT, 0, alphaOffset);
278         }
279 }
280
281
282 static void draw_fcurve_vertices (SpaceIpo *sipo, ARegion *ar, FCurve *fcu, short do_handles, short sel_handle_only)
283 {
284         View2D *v2d= &ar->v2d;
285         
286         /* only draw points if curve is visible 
287          *      - draw unselected points before selected points as separate passes to minimise color-changing overhead
288          *         (XXX dunno if this is faster than drawing all in one pass though) 
289          *         and also to make sure in the case of overlapping points that the selected is always visible
290          *      - draw handles before keyframes, so that keyframes will overlap handles (keyframes are more important for users)
291          */
292         
293         glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE));
294         
295         /* draw the two handles first (if they're shown, the curve doesn't have just a single keyframe, and the curve is being edited) */
296         if (do_handles) {
297                 set_fcurve_vertex_color(fcu, 0);
298                 draw_fcurve_vertices_handles(fcu, sipo, v2d, 0, sel_handle_only);
299                 
300                 set_fcurve_vertex_color(fcu, 1);
301                 draw_fcurve_vertices_handles(fcu, sipo, v2d, 1, sel_handle_only);
302         }
303                 
304         /* draw keyframes over the handles */
305         set_fcurve_vertex_color(fcu, 0);
306         draw_fcurve_vertices_keyframes(fcu, sipo, v2d, !(fcu->flag & FCURVE_PROTECTED), 0);
307         
308         set_fcurve_vertex_color(fcu, 1);
309         draw_fcurve_vertices_keyframes(fcu, sipo, v2d, !(fcu->flag & FCURVE_PROTECTED), 1);
310         
311         glPointSize(1.0f);
312 }
313
314 /* Handles ---------------- */
315
316 static int draw_fcurve_handles_check(SpaceIpo *sipo, FCurve *fcu)
317 {
318         /* don't draw handle lines if handles are not to be shown */
319         if (    (sipo->flag & SIPO_NOHANDLES) || /* handles shouldn't be shown anywhere */
320                         (fcu->flag & FCURVE_PROTECTED) || /* keyframes aren't editable */
321 #if 0           /* handles can still be selected and handle types set, better draw - campbell */
322                         (fcu->flag & FCURVE_INT_VALUES) || /* editing the handles here will cause weird/incorrect interpolation issues */
323 #endif
324                         ((fcu->grp) && (fcu->grp->flag & AGRP_PROTECTED)) || /* group that curve belongs to is not editable */
325                         (fcu->totvert <= 1) /* do not show handles if there is only 1 keyframe, otherwise they all clump together in an ugly ball */
326                 ) 
327         {
328                 return 0;
329         } 
330         else {
331                 return 1;
332         }
333 }
334
335 /* draw lines for F-Curve handles only (this is only done in EditMode)
336  * note: draw_fcurve_handles_check must be checked before running this. */
337 static void draw_fcurve_handles (SpaceIpo *sipo, FCurve *fcu)
338 {
339         int sel, b;
340         
341         /* a single call to GL_LINES here around these calls should be sufficient to still
342          * get separate line segments, but which aren't wrapped with GL_LINE_STRIP every time we
343          * want a single line
344          */
345         glBegin(GL_LINES);
346         
347         /* slightly hacky, but we want to draw unselected points before selected ones 
348          * so that selected points are clearly visible
349          */
350         for (sel= 0; sel < 2; sel++) {
351                 BezTriple *bezt=fcu->bezt, *prevbezt=NULL;
352                 int basecol= (sel)? TH_HANDLE_SEL_FREE : TH_HANDLE_FREE;
353                 float *fp;
354                 unsigned char col[4];
355                 
356                 for (b= 0; b < fcu->totvert; b++, prevbezt=bezt, bezt++) {
357                         /* if only selected keyframes can get their handles shown, 
358                          * check that keyframe is selected
359                          */
360                         if (sipo->flag & SIPO_SELVHANDLESONLY) {
361                                 if (BEZSELECTED(bezt) == 0)
362                                         continue;
363                         }
364                         
365                         /* draw handle with appropriate set of colors if selection is ok */
366                         if ((bezt->f2 & SELECT)==sel) {
367                                 fp= bezt->vec[0];
368                                 
369                                 /* only draw first handle if previous segment had handles */
370                                 if ((!prevbezt && (bezt->ipo==BEZT_IPO_BEZ)) || (prevbezt && (prevbezt->ipo==BEZT_IPO_BEZ))) {
371                                         UI_GetThemeColor3ubv(basecol + bezt->h1, col);
372                                         col[3]= drawFCurveFade(fcu) * 255;
373                                         glColor4ubv((GLubyte *)col);
374                                         
375                                         glVertex2fv(fp); glVertex2fv(fp+3); 
376                                 }
377                                 
378                                 /* only draw second handle if this segment is bezier */
379                                 if (bezt->ipo == BEZT_IPO_BEZ) {
380                                         UI_GetThemeColor3ubv(basecol + bezt->h2, col);
381                                         col[3]= drawFCurveFade(fcu) * 255;
382                                         glColor4ubv((GLubyte *)col);
383                                         
384                                         glVertex2fv(fp+3); glVertex2fv(fp+6); 
385                                 }
386                         }
387                         else {
388                                 /* only draw first handle if previous segment was had handles, and selection is ok */
389                                 if ( ((bezt->f1 & SELECT)==sel) && 
390                                          ( (!prevbezt && (bezt->ipo==BEZT_IPO_BEZ)) || (prevbezt && (prevbezt->ipo==BEZT_IPO_BEZ)) ) ) 
391                                 {
392                                         fp= bezt->vec[0];
393                                         UI_GetThemeColor3ubv(basecol + bezt->h1, col);
394                                         col[3]= drawFCurveFade(fcu) * 255;
395                                         glColor4ubv((GLubyte *)col);
396                                         
397                                         glVertex2fv(fp); glVertex2fv(fp+3); 
398                                 }
399                                 
400                                 /* only draw second handle if this segment is bezier, and selection is ok */
401                                 if ( ((bezt->f3 & SELECT)==sel) &&
402                                          (bezt->ipo == BEZT_IPO_BEZ) )
403                                 {
404                                         fp= bezt->vec[1];
405                                         UI_GetThemeColor3ubv(basecol + bezt->h2, col);
406                                         col[3]= drawFCurveFade(fcu) * 255;
407                                         glColor4ubv((GLubyte *)col);
408                                         
409                                         glVertex2fv(fp); glVertex2fv(fp+3); 
410                                 }
411                         }
412                 }
413         }
414         
415         glEnd(); // GL_LINES 
416 }
417
418 /* Samples ---------------- */
419
420 /* helper func - draw sample-range marker for an F-Curve as a cross 
421  * NOTE: the caller MUST HAVE GL_LINE_SMOOTH & GL_BLEND ENABLED, otherwise, the controls don't 
422  * have a consistent appearance (due to off-pixel alignments)...
423  */
424 static void draw_fcurve_sample_control (float x, float y, float xscale, float yscale, float hsize)
425 {
426         static GLuint displist=0;
427         
428         /* initialize X shape */
429         if (displist == 0) {
430                 displist= glGenLists(1);
431                 glNewList(displist, GL_COMPILE);
432                 
433                 glBegin(GL_LINES);
434                         glVertex2f(-0.7f, -0.7f);
435                         glVertex2f(+0.7f, +0.7f);
436                         
437                         glVertex2f(-0.7f, +0.7f);
438                         glVertex2f(+0.7f, -0.7f);
439                 glEnd(); // GL_LINES
440                 
441                 glEndList();
442         }
443         
444         /* adjust view transform before starting */
445         glTranslatef(x, y, 0.0f);
446         glScalef(1.0f/xscale*hsize, 1.0f/yscale*hsize, 1.0f);
447         
448         /* draw! */
449         glCallList(displist);
450         
451         /* restore view transform */
452         glScalef(xscale/hsize, yscale/hsize, 1.0);
453         glTranslatef(-x, -y, 0.0f);
454 }
455
456 /* helper func - draw keyframe vertices only for an F-Curve */
457 static void draw_fcurve_samples (SpaceIpo *sipo, ARegion *ar, FCurve *fcu)
458 {
459         FPoint *first, *last;
460         float hsize, xscale, yscale;
461         
462         /* get view settings */
463         hsize= UI_GetThemeValuef(TH_VERTEX_SIZE);
464         UI_view2d_getscale(&ar->v2d, &xscale, &yscale);
465         
466         /* set vertex color */
467         if (fcu->flag & (FCURVE_ACTIVE|FCURVE_SELECTED)) UI_ThemeColor(TH_TEXT_HI);
468         else UI_ThemeColor(TH_TEXT);
469         
470         /* get verts */
471         first= fcu->fpt;
472         last= (first) ? (first + (fcu->totvert-1)) : (NULL);
473         
474         /* draw */
475         if (first && last) {
476                 /* anti-aliased lines for more consistent appearance */
477                 if ((sipo->flag & SIPO_BEAUTYDRAW_OFF)==0) glEnable(GL_LINE_SMOOTH);
478                 glEnable(GL_BLEND);
479                 
480                 draw_fcurve_sample_control(first->vec[0], first->vec[1], xscale, yscale, hsize);
481                 draw_fcurve_sample_control(last->vec[0], last->vec[1], xscale, yscale, hsize);
482                 
483                 glDisable(GL_BLEND);
484                 if ((sipo->flag & SIPO_BEAUTYDRAW_OFF)==0) glDisable(GL_LINE_SMOOTH);
485         }
486 }
487
488 /* Curve ---------------- */
489
490 /* helper func - just draw the F-Curve by sampling the visible region (for drawing curves with modifiers) */
491 static void draw_fcurve_curve (bAnimContext *ac, ID *id, FCurve *fcu, View2D *v2d, View2DGrid *grid)
492 {
493         ChannelDriver *driver;
494         float samplefreq, ctime;
495         float stime, etime;
496         float unitFac;
497         float dx, dy;
498
499         /* when opening a blend file on a different sized screen or while dragging the toolbar this can happen
500          * best just bail out in this case */
501         UI_view2d_grid_size(grid, &dx, &dy);
502         if (dx <= 0.0f)
503                 return;
504
505
506         /* disable any drivers temporarily */
507         driver= fcu->driver;
508         fcu->driver= NULL;
509         
510         /* compute unit correction factor */
511         unitFac= ANIM_unit_mapping_get_factor(ac->scene, id, fcu, 0);
512         
513         /* Note about sampling frequency:
514          *      Ideally, this is chosen such that we have 1-2 pixels = 1 segment
515          *      which means that our curves can be as smooth as possible. However,
516          *      this does mean that curves may not be fully accurate (i.e. if they have
517          *      sudden spikes which happen at the sampling point, we may have problems).
518          *      Also, this may introduce lower performance on less densely detailed curves,'
519          *      though it is impossible to predict this from the modifiers!
520          *
521          *      If the automatically determined sampling frequency is likely to cause an infinite
522          *      loop (i.e. too close to 0), then clamp it to a determined "safe" value. The value
523          *      chosen here is just the coarsest value which still looks reasonable...
524          */
525                 /* grid->dx represents the number of 'frames' between gridlines, but we divide by U.v2d_min_gridsize to get pixels-steps */
526                 // TODO: perhaps we should have 1.0 frames as upper limit so that curves don't get too distorted?
527         samplefreq= dx / U.v2d_min_gridsize;
528         if (samplefreq < 0.00001f) samplefreq= 0.00001f;
529         
530         
531         /* the start/end times are simply the horizontal extents of the 'cur' rect */
532         stime= v2d->cur.xmin;
533         etime= v2d->cur.xmax + samplefreq; /* + samplefreq here so that last item gets included... */
534         
535         
536         /* at each sampling interval, add a new vertex 
537          *      - apply the unit correction factor to the calculated values so that 
538          *        the displayed values appear correctly in the viewport
539          */
540         glBegin(GL_LINE_STRIP);
541         
542         for (ctime= stime; ctime <= etime; ctime += samplefreq)
543                 glVertex2f( ctime, evaluate_fcurve(fcu, ctime)*unitFac );
544         
545         glEnd();
546         
547         /* restore driver */
548         fcu->driver= driver;
549 }
550
551 /* helper func - draw a samples-based F-Curve */
552 static void draw_fcurve_curve_samples (bAnimContext *ac, ID *id, FCurve *fcu, View2D *v2d)
553 {
554         FPoint *prevfpt= fcu->fpt;
555         FPoint *fpt= prevfpt + 1;
556         float fac, v[2];
557         int b= fcu->totvert-1;
558         
559         glBegin(GL_LINE_STRIP);
560         
561         /* apply unit mapping */
562         ANIM_unit_mapping_apply_fcurve(ac->scene, id, fcu, 0);
563         
564         /* extrapolate to left? - left-side of view comes before first keyframe? */
565         if (prevfpt->vec[0] > v2d->cur.xmin) {
566                 v[0]= v2d->cur.xmin;
567                 
568                 /* y-value depends on the interpolation */
569                 if ((fcu->extend==FCURVE_EXTRAPOLATE_CONSTANT) || (fcu->flag & FCURVE_INT_VALUES) || (fcu->totvert==1)) {
570                         /* just extend across the first keyframe's value */
571                         v[1]= prevfpt->vec[1];
572                 } 
573                 else {
574                         /* extrapolate linear dosnt use the handle, use the next points center instead */
575                         fac= (prevfpt->vec[0]-fpt->vec[0])/(prevfpt->vec[0]-v[0]);
576                         if (fac) fac= 1.0f/fac;
577                         v[1]= prevfpt->vec[1]-fac*(prevfpt->vec[1]-fpt->vec[1]);
578                 }
579                 
580                 glVertex2fv(v);
581         }
582         
583         /* if only one sample, add it now */
584         if (fcu->totvert == 1)
585                 glVertex2fv(prevfpt->vec);
586         
587         /* loop over samples, drawing segments */
588         /* draw curve between first and last keyframe (if there are enough to do so) */
589         while (b--) {
590                 /* Linear interpolation: just add one point (which should add a new line segment) */
591                 glVertex2fv(prevfpt->vec);
592                 
593                 /* get next pointers */
594                 prevfpt= fpt; 
595                 fpt++;
596                 
597                 /* last point? */
598                 if (b == 0)
599                         glVertex2fv(prevfpt->vec);
600         }
601         
602         /* extrapolate to right? (see code for left-extrapolation above too) */
603         if (prevfpt->vec[0] < v2d->cur.xmax) {
604                 v[0]= v2d->cur.xmax;
605                 
606                 /* y-value depends on the interpolation */
607                 if ((fcu->extend==FCURVE_EXTRAPOLATE_CONSTANT) || (fcu->flag & FCURVE_INT_VALUES) || (fcu->totvert==1)) {
608                         /* based on last keyframe's value */
609                         v[1]= prevfpt->vec[1];
610                 } 
611                 else {
612                         /* extrapolate linear dosnt use the handle, use the previous points center instead */
613                         fpt = prevfpt-1;
614                         fac= (prevfpt->vec[0]-fpt->vec[0])/(prevfpt->vec[0]-v[0]);
615                         if (fac) fac= 1.0f/fac;
616                         v[1]= prevfpt->vec[1]-fac*(prevfpt->vec[1]-fpt->vec[1]);
617                 }
618                 
619                 glVertex2fv(v);
620         }
621         
622         /* unapply unit mapping */
623         ANIM_unit_mapping_apply_fcurve(ac->scene, id, fcu, ANIM_UNITCONV_RESTORE);
624         
625         glEnd();
626 }
627
628 /* helper func - draw one repeat of an F-Curve */
629 static void draw_fcurve_curve_bezts (bAnimContext *ac, ID *id, FCurve *fcu, View2D *v2d)
630 {
631         BezTriple *prevbezt= fcu->bezt;
632         BezTriple *bezt= prevbezt+1;
633         float v1[2], v2[2], v3[2], v4[2];
634         float *fp, data[120];
635         float fac= 0.0f;
636         int b= fcu->totvert-1;
637         int resol;
638         
639         glBegin(GL_LINE_STRIP);
640         
641         /* apply unit mapping */
642         ANIM_unit_mapping_apply_fcurve(ac->scene, id, fcu, 0);
643         
644         /* extrapolate to left? */
645         if (prevbezt->vec[1][0] > v2d->cur.xmin) {
646                 /* left-side of view comes before first keyframe, so need to extend as not cyclic */
647                 v1[0]= v2d->cur.xmin;
648                 
649                 /* y-value depends on the interpolation */
650                 if ((fcu->extend==FCURVE_EXTRAPOLATE_CONSTANT) || (prevbezt->ipo==BEZT_IPO_CONST) || (fcu->totvert==1)) {
651                         /* just extend across the first keyframe's value */
652                         v1[1]= prevbezt->vec[1][1];
653                 } 
654                 else if (prevbezt->ipo==BEZT_IPO_LIN) {
655                         /* extrapolate linear dosnt use the handle, use the next points center instead */
656                         fac= (prevbezt->vec[1][0]-bezt->vec[1][0])/(prevbezt->vec[1][0]-v1[0]);
657                         if (fac) fac= 1.0f/fac;
658                         v1[1]= prevbezt->vec[1][1]-fac*(prevbezt->vec[1][1]-bezt->vec[1][1]);
659                 } 
660                 else {
661                         /* based on angle of handle 1 (relative to keyframe) */
662                         fac= (prevbezt->vec[0][0]-prevbezt->vec[1][0])/(prevbezt->vec[1][0]-v1[0]);
663                         if (fac) fac= 1.0f/fac;
664                         v1[1]= prevbezt->vec[1][1]-fac*(prevbezt->vec[0][1]-prevbezt->vec[1][1]);
665                 }
666                 
667                 glVertex2fv(v1);
668         }
669         
670         /* if only one keyframe, add it now */
671         if (fcu->totvert == 1) {
672                 v1[0]= prevbezt->vec[1][0];
673                 v1[1]= prevbezt->vec[1][1];
674                 glVertex2fv(v1);
675         }
676         
677         /* draw curve between first and last keyframe (if there are enough to do so) */
678         // TODO: optimize this to not have to calc stuff out of view too?
679         while (b--) {
680                 if (prevbezt->ipo==BEZT_IPO_CONST) {
681                         /* Constant-Interpolation: draw segment between previous keyframe and next, but holding same value */
682                         v1[0]= prevbezt->vec[1][0];
683                         v1[1]= prevbezt->vec[1][1];
684                         glVertex2fv(v1);
685                         
686                         v1[0]= bezt->vec[1][0];
687                         v1[1]= prevbezt->vec[1][1];
688                         glVertex2fv(v1);
689                 }
690                 else if (prevbezt->ipo==BEZT_IPO_LIN) {
691                         /* Linear interpolation: just add one point (which should add a new line segment) */
692                         v1[0]= prevbezt->vec[1][0];
693                         v1[1]= prevbezt->vec[1][1];
694                         glVertex2fv(v1);
695                 }
696                 else {
697                         /* Bezier-Interpolation: draw curve as series of segments between keyframes 
698                          *      - resol determines number of points to sample in between keyframes
699                          */
700                         
701                         /* resol depends on distance between points (not just horizontal) OR is a fixed high res */
702                         // TODO: view scale should factor into this someday too...
703                         if (fcu->driver) 
704                                 resol= 32;
705                         else 
706                                 resol= (int)(5.0f*len_v2v2(bezt->vec[1], prevbezt->vec[1]));
707                         
708                         if (resol < 2) {
709                                 /* only draw one */
710                                 v1[0]= prevbezt->vec[1][0];
711                                 v1[1]= prevbezt->vec[1][1];
712                                 glVertex2fv(v1);
713                         }
714                         else {
715                                 /* clamp resolution to max of 32 */
716                                 // NOTE: higher values will crash
717                                 if (resol > 32) resol= 32;
718                                 
719                                 v1[0]= prevbezt->vec[1][0];
720                                 v1[1]= prevbezt->vec[1][1];
721                                 v2[0]= prevbezt->vec[2][0];
722                                 v2[1]= prevbezt->vec[2][1];
723                                 
724                                 v3[0]= bezt->vec[0][0];
725                                 v3[1]= bezt->vec[0][1];
726                                 v4[0]= bezt->vec[1][0];
727                                 v4[1]= bezt->vec[1][1];
728                                 
729                                 correct_bezpart(v1, v2, v3, v4);
730                                 
731                                 forward_diff_bezier(v1[0], v2[0], v3[0], v4[0], data, resol, sizeof(float)*3);
732                                 forward_diff_bezier(v1[1], v2[1], v3[1], v4[1], data+1, resol, sizeof(float)*3);
733                                 
734                                 for (fp= data; resol; resol--, fp+= 3)
735                                         glVertex2fv(fp);
736                         }
737                 }
738                 
739                 /* get next pointers */
740                 prevbezt= bezt; 
741                 bezt++;
742                 
743                 /* last point? */
744                 if (b == 0) {
745                         v1[0]= prevbezt->vec[1][0];
746                         v1[1]= prevbezt->vec[1][1];
747                         glVertex2fv(v1);
748                 }
749         }
750         
751         /* extrapolate to right? (see code for left-extrapolation above too) */
752         if (prevbezt->vec[1][0] < v2d->cur.xmax) {
753                 v1[0]= v2d->cur.xmax;
754                 
755                 /* y-value depends on the interpolation */
756                 if ((fcu->extend==FCURVE_EXTRAPOLATE_CONSTANT) || (fcu->flag & FCURVE_INT_VALUES) || (prevbezt->ipo==BEZT_IPO_CONST) || (fcu->totvert==1)) {
757                         /* based on last keyframe's value */
758                         v1[1]= prevbezt->vec[1][1];
759                 } 
760                 else if (prevbezt->ipo==BEZT_IPO_LIN) {
761                         /* extrapolate linear dosnt use the handle, use the previous points center instead */
762                         bezt = prevbezt-1;
763                         fac= (prevbezt->vec[1][0]-bezt->vec[1][0])/(prevbezt->vec[1][0]-v1[0]);
764                         if (fac) fac= 1.0f/fac;
765                         v1[1]= prevbezt->vec[1][1]-fac*(prevbezt->vec[1][1]-bezt->vec[1][1]);
766                 } 
767                 else {
768                         /* based on angle of handle 1 (relative to keyframe) */
769                         fac= (prevbezt->vec[2][0]-prevbezt->vec[1][0])/(prevbezt->vec[1][0]-v1[0]);
770                         if (fac) fac= 1.0f/fac;
771                         v1[1]= prevbezt->vec[1][1]-fac*(prevbezt->vec[2][1]-prevbezt->vec[1][1]);
772                 }
773                 
774                 glVertex2fv(v1);
775         }
776         
777         /* unapply unit mapping */
778         ANIM_unit_mapping_apply_fcurve(ac->scene, id, fcu, ANIM_UNITCONV_RESTORE);
779         
780         glEnd();
781
782
783 /* Public Curve-Drawing API  ---------------- */
784
785 /* Draw the 'ghost' F-Curves (i.e. snapshots of the curve) 
786  * NOTE: unit mapping has already been applied to the values, so do not try and apply again
787  */
788 void graph_draw_ghost_curves (bAnimContext *ac, SpaceIpo *sipo, ARegion *ar)
789 {
790         FCurve *fcu;
791         
792         /* draw with thick dotted lines */
793         setlinestyle(10);
794         glLineWidth(3.0f);
795         
796         /* anti-aliased lines for less jagged appearance */
797         if ((sipo->flag & SIPO_BEAUTYDRAW_OFF)==0) glEnable(GL_LINE_SMOOTH);
798         glEnable(GL_BLEND);
799         
800         /* the ghost curves are simply sampled F-Curves stored in sipo->ghostCurves */
801         for (fcu= sipo->ghostCurves.first; fcu; fcu= fcu->next) {
802                 /* set whatever color the curve has set 
803                  *      - this is set by the function which creates these
804                  *      - draw with a fixed opacity of 2
805                  */
806                 glColor4f(fcu->color[0], fcu->color[1], fcu->color[2], 0.5f);
807                 
808                 /* simply draw the stored samples */
809                 draw_fcurve_curve_samples(ac, NULL, fcu, &ar->v2d);
810         }
811         
812         /* restore settings */
813         setlinestyle(0);
814         glLineWidth(1.0f);
815         
816         if ((sipo->flag & SIPO_BEAUTYDRAW_OFF)==0) glDisable(GL_LINE_SMOOTH);
817         glDisable(GL_BLEND);
818 }
819
820 /* This is called twice from space_graph.c -> graph_main_area_draw()
821  * Unselected then selected F-Curves are drawn so that they do not occlude each other.
822  */
823 void graph_draw_curves (bAnimContext *ac, SpaceIpo *sipo, ARegion *ar, View2DGrid *grid, short sel)
824 {
825         ListBase anim_data = {NULL, NULL};
826         bAnimListElem *ale;
827         int filter;
828         
829         /* build list of curves to draw */
830         filter= (ANIMFILTER_DATA_VISIBLE|ANIMFILTER_CURVE_VISIBLE);
831         filter |= ((sel) ? (ANIMFILTER_SEL) : (ANIMFILTER_UNSEL));
832         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
833                 
834         /* for each curve:
835          *      draw curve, then handle-lines, and finally vertices in this order so that 
836          *      the data will be layered correctly
837          */
838         for (ale=anim_data.first; ale; ale=ale->next) {
839                 FCurve *fcu= (FCurve *)ale->key_data;
840                 FModifier *fcm= find_active_fmodifier(&fcu->modifiers);
841                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
842                 
843                 /* map keyframes for drawing if scaled F-Curve */
844                 if (adt)
845                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 0); 
846                 
847                 /* draw curve:
848                  *      - curve line may be result of one or more destructive modifiers or just the raw data,
849                  *        so we need to check which method should be used
850                  *      - controls from active modifier take precedence over keyframes
851                  *        (XXX! editing tools need to take this into account!)
852                  */
853                  
854                 /* 1) draw curve line */
855                 {
856                         /* set color/drawing style for curve itself */
857                         if ( ((fcu->grp) && (fcu->grp->flag & AGRP_PROTECTED)) || (fcu->flag & FCURVE_PROTECTED) ) {
858                                 /* protected curves (non editable) are drawn with dotted lines */
859                                 setlinestyle(2);
860                         }
861                         if ( ((fcu->grp) && (fcu->grp->flag & AGRP_MUTED)) || (fcu->flag & FCURVE_MUTED) ) {
862                                 /* muted curves are drawn in a greyish hue */
863                                 // XXX should we have some variations?
864                                 UI_ThemeColorShade(TH_HEADER, 50);
865                         }
866                         else {
867                                 /* set whatever color the curve has set 
868                                  *      - unselected curves draw less opaque to help distinguish the selected ones
869                                  */
870                                 glColor4f(fcu->color[0], fcu->color[1], fcu->color[2], drawFCurveFade(fcu));
871                         }
872                         
873                         /* draw active F-Curve thicker than the rest to make it stand out */
874                         if (fcu->flag & FCURVE_ACTIVE) {
875                                 glLineWidth(2.0);
876                         }
877                         
878                         /* anti-aliased lines for less jagged appearance */
879                         if ((sipo->flag & SIPO_BEAUTYDRAW_OFF)==0) glEnable(GL_LINE_SMOOTH);
880                         glEnable(GL_BLEND);
881                         
882                         /* draw F-Curve */
883                         if ((fcu->modifiers.first) || (fcu->flag & FCURVE_INT_VALUES)) {
884                                 /* draw a curve affected by modifiers or only allowed to have integer values 
885                                  * by sampling it at various small-intervals over the visible region 
886                                  */
887                                 draw_fcurve_curve(ac, ale->id, fcu, &ar->v2d, grid);
888                         }
889                         else if ( ((fcu->bezt) || (fcu->fpt)) && (fcu->totvert) ) { 
890                                 /* just draw curve based on defined data (i.e. no modifiers) */
891                                 if (fcu->bezt)
892                                         draw_fcurve_curve_bezts(ac, ale->id, fcu, &ar->v2d);
893                                 else if (fcu->fpt)
894                                         draw_fcurve_curve_samples(ac, ale->id, fcu, &ar->v2d);
895                         }
896                         
897                         /* restore settings */
898                         setlinestyle(0);
899                         glLineWidth(1.0);
900                         
901                         if ((sipo->flag & SIPO_BEAUTYDRAW_OFF)==0) glDisable(GL_LINE_SMOOTH);
902                         glDisable(GL_BLEND);
903                 }
904                 
905                 /* 2) draw handles and vertices as appropriate based on active 
906                  *      - if the option to only show controls if the F-Curve is selected is enabled, we must obey this
907                  */
908                 if (!(sipo->flag & SIPO_SELCUVERTSONLY) || (fcu->flag & FCURVE_SELECTED)) {
909                         if (fcurve_are_keyframes_usable(fcu) == 0) {
910                                 /* only draw controls if this is the active modifier */
911                                 if ((fcu->flag & FCURVE_ACTIVE) && (fcm)) {
912                                         switch (fcm->type) {
913                                                 case FMODIFIER_TYPE_ENVELOPE: /* envelope */
914                                                         draw_fcurve_modifier_controls_envelope(fcm, &ar->v2d);
915                                                         break;
916                                         }
917                                 }
918                         }
919                         else if ( ((fcu->bezt) || (fcu->fpt)) && (fcu->totvert) ) { 
920                                 /* apply unit mapping */
921                                 ANIM_unit_mapping_apply_fcurve(ac->scene, ale->id, fcu, 0);
922                                 
923                                 if (fcu->bezt) {
924                                         int do_handles = draw_fcurve_handles_check(sipo, fcu);
925                                         
926                                         if (do_handles) {
927                                                 /* only draw handles/vertices on keyframes */
928                                                 glEnable(GL_BLEND);
929                                                 draw_fcurve_handles(sipo, fcu);
930                                                 glDisable(GL_BLEND);
931                                         }
932                                         
933                                         draw_fcurve_vertices(sipo, ar, fcu, do_handles, (sipo->flag & SIPO_SELVHANDLESONLY));
934                                 }
935                                 else {
936                                         /* samples: only draw two indicators at either end as indicators */
937                                         draw_fcurve_samples(sipo, ar, fcu);
938                                 }
939                                 
940                                 /* unapply unit mapping */
941                                 ANIM_unit_mapping_apply_fcurve(ac->scene, ale->id, fcu, ANIM_UNITCONV_RESTORE);
942                         }
943                 }
944                 
945                 /* undo mapping of keyframes for drawing if scaled F-Curve */
946                 if (adt)
947                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 0); 
948         }
949         
950         /* free list of curves */
951         BLI_freelistN(&anim_data);
952 }
953
954 /* ************************************************************************* */
955 /* Channel List */
956
957 /* left hand part */
958 void graph_draw_channel_names(bContext *C, bAnimContext *ac, ARegion *ar) 
959 {
960         ListBase anim_data = {NULL, NULL};
961         bAnimListElem *ale;
962         int filter;
963         
964         View2D *v2d= &ar->v2d;
965         float y= 0.0f, height;
966         size_t items;
967         int i=0;
968         
969         /* build list of channels to draw */
970         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);
971         items= ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
972         
973         /* Update max-extent of channels here (taking into account scrollers):
974          *      - this is done to allow the channel list to be scrollable, but must be done here
975          *        to avoid regenerating the list again and/or also because channels list is drawn first
976          *      - offset of ACHANNEL_HEIGHT*2 is added to the height of the channels, as first is for 
977          *        start of list offset, and the second is as a correction for the scrollers.
978          */
979         height= (float)((items*ACHANNEL_STEP) + (ACHANNEL_HEIGHT*2));
980         UI_view2d_totRect_set(v2d, ar->winx, height);
981         
982         /* loop through channels, and set up drawing depending on their type  */        
983         {       /* first pass: just the standard GL-drawing for backdrop + text */
984                 y= (float)ACHANNEL_FIRST;
985                 
986                 for (ale= anim_data.first, i=0; ale; ale= ale->next, i++) {
987                         const float yminc= (float)(y - ACHANNEL_HEIGHT_HALF);
988                         const float ymaxc= (float)(y + ACHANNEL_HEIGHT_HALF);
989                         
990                         /* check if visible */
991                         if ( IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
992                                  IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) ) 
993                         {
994                                 /* draw all channels using standard channel-drawing API */
995                                 ANIM_channel_draw(ac, ale, yminc, ymaxc);
996                         }
997                         
998                         /* adjust y-position for next one */
999                         y -= ACHANNEL_STEP;
1000                 }
1001         }
1002         {       /* second pass: widgets */
1003                 uiBlock *block= uiBeginBlock(C, ar, __func__, UI_EMBOSS);
1004                 size_t channel_index = 0;
1005                 
1006                 y= (float)ACHANNEL_FIRST;
1007                 
1008                 /* set blending again, as may not be set in previous step */
1009                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1010                 glEnable(GL_BLEND);
1011                 
1012                 for (ale= anim_data.first, i=0; ale; ale= ale->next, i++) {
1013                         const float yminc= (float)(y - ACHANNEL_HEIGHT_HALF);
1014                         const float ymaxc= (float)(y + ACHANNEL_HEIGHT_HALF);
1015                         
1016                         /* check if visible */
1017                         if ( IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
1018                                  IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) ) 
1019                         {
1020                                 /* draw all channels using standard channel-drawing API */
1021                                 ANIM_channel_draw_widgets(C, ac, ale, block, yminc, ymaxc, channel_index);
1022                         }
1023                         
1024                         /* adjust y-position for next one */
1025                         y -= ACHANNEL_STEP;
1026                         channel_index++;
1027                 }
1028                 
1029                 uiEndBlock(C, block);
1030                 uiDrawBlock(C, block);
1031                 
1032                 glDisable(GL_BLEND);
1033         }
1034         
1035         /* free tempolary channels */
1036         BLI_freelistN(&anim_data);
1037 }