Edit Mode overlay: Optimisation
[blender.git] / source / blender / editors / space_nla / nla_draw.c
1
2 /*
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. 
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
20  * All rights reserved.
21  *
22  * 
23  * Contributor(s): Joshua Leung (major recode)
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/space_nla/nla_draw.c
29  *  \ingroup spnla
30  */
31
32
33 #include <string.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <math.h>
37 #include <float.h>
38
39 #include "DNA_anim_types.h"
40 #include "DNA_node_types.h"
41 #include "DNA_screen_types.h"
42 #include "DNA_space_types.h"
43 #include "DNA_windowmanager_types.h"
44
45 #include "BLI_blenlib.h"
46 #include "BLI_dlrbTree.h"
47 #include "BLI_utildefines.h"
48
49 #include "BKE_fcurve.h"
50 #include "BKE_nla.h"
51 #include "BKE_context.h"
52 #include "BKE_screen.h"
53
54 #include "ED_anim_api.h"
55 #include "ED_keyframes_draw.h"
56
57 #include "BIF_glutil.h"
58
59 #include "GPU_immediate.h"
60 #include "GPU_draw.h"
61
62 #include "WM_types.h"
63
64 #include "UI_interface.h"
65 #include "UI_resources.h"
66 #include "UI_view2d.h"
67
68 #include "nla_private.h"
69 #include "nla_intern.h" /* own include */
70
71
72 /* *********************************************** */
73 /* Strips */
74
75 /* Action-Line ---------------------- */
76
77 /* get colors for drawing Action-Line 
78  * NOTE: color returned includes fine-tuned alpha!
79  */
80 void nla_action_get_color(AnimData *adt, bAction *act, float color[4])
81 {
82         if (adt && (adt->flag & ADT_NLA_EDIT_ON)) {
83                 /* greenish color (same as tweaking strip) */
84                 UI_GetThemeColor4fv(TH_NLA_TWEAK, color);
85         }
86         else {
87                 if (act) {
88                         /* reddish color - same as dopesheet summary */
89                         UI_GetThemeColor4fv(TH_ANIM_ACTIVE, color);
90                 }
91                 else {
92                         /* grayish-red color */
93                         UI_GetThemeColor4fv(TH_ANIM_INACTIVE, color);
94                 }
95         }
96         
97         /* when an NLA track is tagged "solo", action doesn't contribute, so shouldn't be as prominent */
98         if (adt && (adt->flag & ADT_NLA_SOLO_TRACK))
99                 color[3] *= 0.15f;
100 }
101
102 /* draw the keyframes in the specified Action */
103 static void nla_action_draw_keyframes(AnimData *adt, bAction *act, float y, float ymin, float ymax)
104 {
105         /* get a list of the keyframes with NLA-scaling applied */
106         DLRBT_Tree keys;
107         BLI_dlrbTree_init(&keys);
108         action_to_keylist(adt, act, &keys, NULL);
109         BLI_dlrbTree_linkedlist_sync(&keys);
110
111         if (!(act && keys.first))
112                 return;
113
114         /* draw a darkened region behind the strips 
115          *      - get and reset the background color, this time without the alpha to stand out better 
116          *        (amplified alpha is used instead)
117          */
118         float color[4];
119         nla_action_get_color(adt, act, color);
120         color[3] *= 2.5f;
121
122         VertexFormat *format = immVertexFormat();
123         unsigned int pos_id = add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
124
125         immUniformColor4fv(color);
126
127         /*  - draw a rect from the first to the last frame (no extra overlaps for now)
128          *        that is slightly stumpier than the track background (hardcoded 2-units here)
129          */
130         float f1 = ((ActKeyColumn *)keys.first)->cfra;
131         float f2 = ((ActKeyColumn *)keys.last)->cfra;
132
133         immRectf(pos_id, f1, ymin + 2, f2, ymax - 2);
134         immUnbindProgram();
135
136         /* count keys before drawing */
137         unsigned int key_ct = 0;
138         for (ActKeyColumn *ak = keys.first; ak; ak = ak->next) {
139                 key_ct++;
140         }
141
142         if (key_ct > 0) {
143                 format = immVertexFormat();
144                 pos_id = add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
145                 unsigned int size_id = add_attrib(format, "size", COMP_F32, 1, KEEP_FLOAT);
146                 unsigned int color_id = add_attrib(format, "color", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
147                 unsigned int outline_color_id = add_attrib(format, "outlineColor", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
148                 immBindBuiltinProgram(GPU_SHADER_KEYFRAME_DIAMOND);
149                 GPU_enable_program_point_size();
150                 immBegin(PRIM_POINTS, key_ct);
151
152                 /* - disregard the selection status of keyframes so they draw a certain way
153                  *      - size is 6.0f which is smaller than the editable keyframes, so that there is a distinction
154                  */
155                 for (ActKeyColumn *ak = keys.first; ak; ak = ak->next) {
156                         draw_keyframe_shape(ak->cfra, y, 6.0f, false, ak->key_type, KEYFRAME_SHAPE_FRAME, 1.0f,
157                                             pos_id, size_id, color_id, outline_color_id);
158                 }
159
160                 immEnd();
161                 GPU_disable_program_point_size();
162                 immUnbindProgram();
163         }
164
165         /* free icons */
166         BLI_dlrbTree_free(&keys);
167 }
168
169 /* Strip Markers ------------------------ */
170
171 /* Markers inside an action strip */
172 static void nla_actionclip_draw_markers(NlaStrip *strip, float yminc, float ymaxc, int shade, unsigned int pos)
173 {
174         const bAction *act = strip->act;
175
176         if (!(act && act->markers.first))
177                 return;
178
179         immUniformThemeColorShade(TH_STRIP_SELECT, shade);
180
181         immBeginAtMost(PRIM_POINTS, BLI_listbase_count(&act->markers));
182         for (TimeMarker *marker = act->markers.first; marker; marker = marker->next) {
183                 if ((marker->frame > strip->actstart) && (marker->frame < strip->actend)) {
184                         float frame = nlastrip_get_frame(strip, marker->frame, NLATIME_CONVERT_MAP);
185
186                         /* just a simple line for now */
187                         /* XXX: draw a triangle instead... */
188                         immVertex2f(pos, frame, yminc + 1);
189                         immVertex2f(pos, frame, ymaxc - 1);
190                 }
191         }
192         immEnd();
193 }
194
195 /* Markers inside a NLA-Strip */
196 static void nla_strip_draw_markers(NlaStrip *strip, float yminc, float ymaxc, unsigned int pos)
197 {
198         glLineWidth(2.0f);
199         
200         if (strip->type == NLASTRIP_TYPE_CLIP) {
201                 /* try not to be too conspicuous, while being visible enough when transforming */
202                 int shade = (strip->flag & NLASTRIP_FLAG_SELECT) ? -60 : -40;
203
204                 setlinestyle(3);
205                 
206                 /* just draw the markers in this clip */
207                 nla_actionclip_draw_markers(strip, yminc, ymaxc, shade, pos);
208                 
209                 setlinestyle(0);
210         }
211         else if (strip->flag & NLASTRIP_FLAG_TEMP_META) {
212                 /* just a solid color, so that it is very easy to spot */
213                 int shade = 20;
214                 /* draw the markers in the first level of strips only (if they are actions) */
215                 for (NlaStrip *nls = strip->strips.first; nls; nls = nls->next) {
216                         if (nls->type == NLASTRIP_TYPE_CLIP) {
217                                 nla_actionclip_draw_markers(nls, yminc, ymaxc, shade, pos);
218                         }
219                 }
220         }
221 }
222
223 /* Strips (Proper) ---------------------- */
224
225 /* get colors for drawing NLA-Strips */
226 static void nla_strip_get_color_inside(AnimData *adt, NlaStrip *strip, float color[3])
227 {
228         if (strip->type == NLASTRIP_TYPE_TRANSITION) {
229                 /* Transition Clip */
230                 if (strip->flag & NLASTRIP_FLAG_SELECT) {
231                         /* selected - use a bright blue color */
232                         UI_GetThemeColor3fv(TH_NLA_TRANSITION_SEL, color);
233                 }
234                 else {
235                         /* normal, unselected strip - use (hardly noticeable) blue tinge */
236                         UI_GetThemeColor3fv(TH_NLA_TRANSITION, color);
237                 }
238         }
239         else if (strip->type == NLASTRIP_TYPE_META) {
240                 /* Meta Clip */
241                 // TODO: should temporary metas get different colors too?
242                 if (strip->flag & NLASTRIP_FLAG_SELECT) {
243                         /* selected - use a bold purple color */
244                         UI_GetThemeColor3fv(TH_NLA_META_SEL, color);
245                 }
246                 else {
247                         /* normal, unselected strip - use (hardly noticeable) dark purple tinge */
248                         UI_GetThemeColor3fv(TH_NLA_META, color);
249                 }
250         }
251         else if (strip->type == NLASTRIP_TYPE_SOUND) {
252                 /* Sound Clip */
253                 if (strip->flag & NLASTRIP_FLAG_SELECT) {
254                         /* selected - use a bright teal color */
255                         UI_GetThemeColor3fv(TH_NLA_SOUND_SEL, color);
256                 }
257                 else {
258                         /* normal, unselected strip - use (hardly noticeable) teal tinge */
259                         UI_GetThemeColor3fv(TH_NLA_SOUND, color);
260                 }
261         }
262         else {
263                 /* Action Clip (default/normal type of strip) */
264                 if (adt && (adt->flag & ADT_NLA_EDIT_ON) && (adt->actstrip == strip)) {
265                         /* active strip should be drawn green when it is acting as the tweaking strip.
266                          * however, this case should be skipped for when not in EditMode...
267                          */
268                         UI_GetThemeColor3fv(TH_NLA_TWEAK, color);
269                 }
270                 else if (strip->flag & NLASTRIP_FLAG_TWEAKUSER) {
271                         /* alert user that this strip is also used by the tweaking track (this is set when going into
272                          * 'editmode' for that strip), since the edits made here may not be what the user anticipated
273                          */
274                         UI_GetThemeColor3fv(TH_NLA_TWEAK_DUPLI, color);
275                 }
276                 else if (strip->flag & NLASTRIP_FLAG_SELECT) {
277                         /* selected strip - use theme color for selected */
278                         UI_GetThemeColor3fv(TH_STRIP_SELECT, color);
279                 }
280                 else {
281                         /* normal, unselected strip - use standard strip theme color */
282                         UI_GetThemeColor3fv(TH_STRIP, color);
283                 }
284         }
285 }
286
287 /* helper call for drawing influence/time control curves for a given NLA-strip */
288 static void nla_draw_strip_curves(NlaStrip *strip, float yminc, float ymaxc, unsigned int pos)
289 {
290         immUniformColor4f(0.7f, 0.7f, 0.7f, 1.0f);
291
292         const float yheight = ymaxc - yminc;
293                 
294         /* draw with AA'd line */
295         glEnable(GL_LINE_SMOOTH);
296         glEnable(GL_BLEND);
297         
298         /* influence -------------------------- */
299         if (strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) {
300                 FCurve *fcu = list_find_fcurve(&strip->fcurves, "influence", 0);
301                 float cfra;
302                 
303                 /* plot the curve (over the strip's main region) */
304                 immBegin(GL_LINE_STRIP, abs((int)(strip->end - strip->start) + 1));
305
306                 /* sample at 1 frame intervals, and draw
307                  *      - min y-val is yminc, max is y-maxc, so clamp in those regions
308                  */
309                 for (cfra = strip->start; cfra <= strip->end; cfra += 1.0f) {
310                         float y = evaluate_fcurve(fcu, cfra); /* assume this to be in 0-1 range */
311                         immVertex2f(pos, cfra, ((y * yheight) + yminc));
312                 }
313
314                 immEnd();
315         }
316         else {
317                 /* use blend in/out values only if both aren't zero */
318                 if ((IS_EQF(strip->blendin, 0.0f) && IS_EQF(strip->blendout, 0.0f)) == 0) {
319                         immBeginAtMost(GL_LINE_STRIP, 4);
320
321                         /* start of strip - if no blendin, start straight at 1, otherwise from 0 to 1 over blendin frames */
322                         if (IS_EQF(strip->blendin, 0.0f) == 0) {
323                                 immVertex2f(pos, strip->start,                    yminc);
324                                 immVertex2f(pos, strip->start + strip->blendin,   ymaxc);
325                         }
326                         else
327                                 immVertex2f(pos, strip->start, ymaxc);
328                                         
329                         /* end of strip */
330                         if (IS_EQF(strip->blendout, 0.0f) == 0) {
331                                 immVertex2f(pos, strip->end - strip->blendout,    ymaxc);
332                                 immVertex2f(pos, strip->end,                      yminc);
333                         }
334                         else
335                                 immVertex2f(pos, strip->end, ymaxc);
336
337                         immEnd();
338                 }
339         }
340
341         /* turn off AA'd lines */
342         glDisable(GL_LINE_SMOOTH);
343         glDisable(GL_BLEND);
344 }
345
346 /* main call for drawing a single NLA-strip */
347 static void nla_draw_strip(SpaceNla *snla, AnimData *adt, NlaTrack *nlt, NlaStrip *strip, View2D *v2d, float yminc, float ymaxc)
348 {
349         const bool non_solo = ((adt && (adt->flag & ADT_NLA_SOLO_TRACK)) && (nlt->flag & NLATRACK_SOLO) == 0);
350         float color[4] = {1.0f, 1.0f, 1.0f, 1.0f};
351
352         /* get color of strip */
353         nla_strip_get_color_inside(adt, strip, color);
354
355         unsigned int pos = add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
356         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
357
358         /* draw extrapolation info first (as backdrop)
359          *      - but this should only be drawn if track has some contribution
360          */
361         if ((strip->extendmode != NLASTRIP_EXTEND_NOTHING) && (non_solo == 0)) {
362                 /* enable transparency... */
363                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
364                 glEnable(GL_BLEND);
365
366                 switch (strip->extendmode) {
367                         /* since this does both sides, only do the 'before' side, and leave the rest to the next case */
368                         case NLASTRIP_EXTEND_HOLD: 
369                                 /* only need to draw here if there's no strip before since 
370                                  * it only applies in such a situation 
371                                  */
372                                 if (strip->prev == NULL) {
373                                         /* set the drawing color to the color of the strip, but with very faint alpha */
374                                         immUniformColor3fvAlpha(color, 0.15f);
375
376                                         /* draw the rect to the edge of the screen */
377                                         immRectf(pos, v2d->cur.xmin, yminc, strip->start, ymaxc);
378                                 }
379                                 /* fall-through */
380
381                         /* this only draws after the strip */
382                         case NLASTRIP_EXTEND_HOLD_FORWARD: 
383                                 /* only need to try and draw if the next strip doesn't occur immediately after */
384                                 if ((strip->next == NULL) || (IS_EQF(strip->next->start, strip->end) == 0)) {
385                                         /* set the drawing color to the color of the strip, but this time less faint */
386                                         immUniformColor3fvAlpha(color, 0.3f);
387                                         
388                                         /* draw the rect to the next strip or the edge of the screen */
389                                         float x2 = strip->next ? strip->next->start : v2d->cur.xmax;
390                                         immRectf(pos, strip->end, yminc, x2, ymaxc);
391                                 }
392                                 break;
393                 }
394
395                 glDisable(GL_BLEND);
396         }
397
398
399         /* draw 'inside' of strip itself */
400         if (non_solo == 0) {
401                 immUnbindProgram();
402
403                 /* strip is in normal track */
404                 UI_draw_roundbox_corner_set(UI_CNR_ALL); /* all corners rounded */
405                 UI_draw_roundbox_shade_x(GL_TRIANGLE_FAN, strip->start, yminc, strip->end, ymaxc, 0.0, 0.5, 0.1, color);
406
407                 /* restore current vertex format & program (roundbox trashes it) */
408                 pos = add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
409                 immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
410         }
411         else {
412                 /* strip is in disabled track - make less visible */
413                 immUniformColor3fvAlpha(color, 0.1f);
414                 
415                 glEnable(GL_BLEND);
416                 immRectf(pos, strip->start, yminc, strip->end, ymaxc);
417                 glDisable(GL_BLEND);
418         }
419
420
421         /* draw strip's control 'curves'
422          *      - only if user hasn't hidden them...
423          */
424         if ((snla->flag & SNLA_NOSTRIPCURVES) == 0)
425                 nla_draw_strip_curves(strip, yminc, ymaxc, pos);
426
427
428         /* draw markings indicating locations of local markers (useful for lining up different actions) */
429         if ((snla->flag & SNLA_NOLOCALMARKERS) == 0)
430                 nla_strip_draw_markers(strip, yminc, ymaxc, pos);
431
432         immUnbindProgram();
433
434         /* draw strip outline
435          *      - color used here is to indicate active vs non-active
436          */
437         if (strip->flag & NLASTRIP_FLAG_ACTIVE) {
438                 /* strip should appear 'sunken', so draw a light border around it */
439                 color[0] = 0.9f; /* FIXME: hardcoded temp-hack colors */
440                 color[1] = 1.0f;
441                 color[2] = 0.9f;
442         }
443         else {
444                 /* strip should appear to stand out, so draw a dark border around it */
445                 color[0] = color[1] = color[2] = 0.0f; /* FIXME: or 1.0f ?? */
446         }
447
448         /* - line style: dotted for muted */
449         if ((nlt->flag & NLATRACK_MUTED) || (strip->flag & NLASTRIP_FLAG_MUTED))
450                 setlinestyle(4);
451
452         /* draw outline */
453         UI_draw_roundbox_shade_x(GL_LINE_LOOP, strip->start, yminc, strip->end, ymaxc, 0.0, 0.0, 0.1, color);
454
455         /* restore current vertex format & program (roundbox trashes it) */
456         pos = add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
457         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
458
459         immUniformColor3fv(color);
460
461         /* if action-clip strip, draw lines delimiting repeats too (in the same color as outline) */
462         if ((strip->type == NLASTRIP_TYPE_CLIP) && IS_EQF(strip->repeat, 1.0f) == 0) {
463                 float repeatLen = (strip->actend - strip->actstart) * strip->scale;
464
465                 /* only draw lines for whole-numbered repeats, starting from the first full-repeat
466                  * up to the last full repeat (but not if it lies on the end of the strip)
467                  */
468                 immBeginAtMost(PRIM_LINES, 2 * (strip->repeat - 1));
469                 for (int i = 1; i < strip->repeat; i++) {
470                         float repeatPos = strip->start + (repeatLen * i);
471
472                         /* don't draw if line would end up on or after the end of the strip */
473                         if (repeatPos < strip->end) {
474                                 immVertex2f(pos, repeatPos, yminc + 4);
475                                 immVertex2f(pos, repeatPos, ymaxc - 4);
476                         }
477                 }
478                 immEnd();
479         }
480         /* or if meta-strip, draw lines delimiting extents of sub-strips (in same color as outline, if more than 1 exists) */
481         else if ((strip->type == NLASTRIP_TYPE_META) && (strip->strips.first != strip->strips.last)) {
482                 float y = (ymaxc - yminc) * 0.5f + yminc;
483
484                 immBeginAtMost(PRIM_LINES, 4 * BLI_listbase_count(&strip->strips)); /* up to 2 lines per strip */
485
486                 /* only draw first-level of child-strips, but don't draw any lines on the endpoints */
487                 for (NlaStrip *cs = strip->strips.first; cs; cs = cs->next) {
488                         /* draw start-line if not same as end of previous (and only if not the first strip) 
489                          *      - on upper half of strip
490                          */
491                         if ((cs->prev) && IS_EQF(cs->prev->end, cs->start) == 0) {
492                                 immVertex2f(pos, cs->start, y);
493                                 immVertex2f(pos, cs->start, ymaxc);
494                         }
495
496                         /* draw end-line if not the last strip
497                          *      - on lower half of strip
498                          */
499                         if (cs->next) {
500                                 immVertex2f(pos, cs->end, yminc);
501                                 immVertex2f(pos, cs->end, y);
502                         }
503                 }
504
505                 immEnd();
506         }
507
508         /* reset linestyle */
509         setlinestyle(0);
510         immUnbindProgram();
511 }
512
513 /* add the relevant text to the cache of text-strings to draw in pixelspace */
514 static void nla_draw_strip_text(
515         AnimData *adt, NlaTrack *nlt, NlaStrip *strip, int index, View2D *v2d,
516         float xminc, float xmaxc, float yminc, float ymaxc)
517 {
518         const bool non_solo = ((adt && (adt->flag & ADT_NLA_SOLO_TRACK)) && (nlt->flag & NLATRACK_SOLO) == 0);
519         char str[256];
520         size_t str_len;
521         char col[4];
522         
523         /* just print the name and the range */
524         if (strip->flag & NLASTRIP_FLAG_TEMP_META) {
525                 str_len = BLI_snprintf_rlen(str, sizeof(str), "%d) Temp-Meta", index);
526         }
527         else {
528                 str_len = BLI_strncpy_rlen(str, strip->name, sizeof(str));
529         }
530         
531         /* set text color - if colors (see above) are light, draw black text, otherwise draw white */
532         if (strip->flag & (NLASTRIP_FLAG_ACTIVE | NLASTRIP_FLAG_SELECT | NLASTRIP_FLAG_TWEAKUSER)) {
533                 col[0] = col[1] = col[2] = 0;
534         }
535         else {
536                 col[0] = col[1] = col[2] = 255;
537         }
538         
539         /* text opacity depends on whether if there's a solo'd track, this isn't it */
540         if (non_solo == 0)
541                 col[3] = 255;
542         else
543                 col[3] = 128;
544
545         /* set bounding-box for text 
546          *      - padding of 2 'units' on either side
547          */
548         /* TODO: make this centered? */
549         rctf rect = {
550                 .xmin = xminc,
551                 .ymin = yminc,
552                 .xmax = xmaxc,
553                 .ymax = ymaxc
554         };
555
556         /* add this string to the cache of texts to draw */
557         UI_view2d_text_cache_add_rectf(v2d, &rect, str, str_len, col);
558 }
559
560 /* add frame extents to cache of text-strings to draw in pixelspace
561  * for now, only used when transforming strips
562  */
563 static void nla_draw_strip_frames_text(NlaTrack *UNUSED(nlt), NlaStrip *strip, View2D *v2d, float UNUSED(yminc), float ymaxc)
564 {
565         const float ytol = 1.0f; /* small offset to vertical positioning of text, for legibility */
566         const char col[4] = {220, 220, 220, 255}; /* light gray */
567         char numstr[32];
568
569         /* Always draw times above the strip, whereas sequencer drew below + above.
570          * However, we should be fine having everything on top, since these tend to be 
571          * quite spaced out. 
572          *      - 1 dp is compromise between lack of precision (ints only, as per sequencer)
573          *        while also preserving some accuracy, since we do use floats
574          */
575         /* start frame */
576         size_t numstr_len = BLI_snprintf_rlen(numstr, sizeof(numstr), "%.1f", strip->start);
577         UI_view2d_text_cache_add(v2d, strip->start - 1.0f, ymaxc + ytol, numstr, numstr_len, col);
578
579         /* end frame */
580         numstr_len = BLI_snprintf_rlen(numstr, sizeof(numstr), "%.1f", strip->end);
581         UI_view2d_text_cache_add(v2d, strip->end, ymaxc + ytol, numstr, numstr_len, col);
582 }
583
584 /* ---------------------- */
585
586 void draw_nla_main_data(bAnimContext *ac, SpaceNla *snla, ARegion *ar)
587 {
588         View2D *v2d = &ar->v2d;
589         const float pixelx = BLI_rctf_size_x(&v2d->cur) / BLI_rcti_size_x(&v2d->mask);
590         const float text_margin_x = (8 * UI_DPI_FAC) * pixelx;
591         
592         /* build list of channels to draw */
593         ListBase anim_data = {NULL, NULL};
594         int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);
595         size_t items = ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
596         
597         /* Update max-extent of channels here (taking into account scrollers):
598          *  - this is done to allow the channel list to be scrollable, but must be done here
599          *    to avoid regenerating the list again and/or also because channels list is drawn first
600          *      - offset of NLACHANNEL_HEIGHT*2 is added to the height of the channels, as first is for 
601          *        start of list offset, and the second is as a correction for the scrollers.
602          */
603         int height = ((items * NLACHANNEL_STEP(snla)) + (NLACHANNEL_HEIGHT(snla) * 2));
604         /* don't use totrect set, as the width stays the same 
605          * (NOTE: this is ok here, the configuration is pretty straightforward) 
606          */
607         v2d->tot.ymin = (float)(-height);
608         
609         /* loop through channels, and set up drawing depending on their type  */
610         float y = (float)(-NLACHANNEL_HEIGHT(snla));
611         
612         for (bAnimListElem *ale = anim_data.first; ale; ale = ale->next) {
613                 const float yminc = (float)(y - NLACHANNEL_HEIGHT_HALF(snla));
614                 const float ymaxc = (float)(y + NLACHANNEL_HEIGHT_HALF(snla));
615                 
616                 /* check if visible */
617                 if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
618                     IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
619                 {
620                         /* data to draw depends on the type of channel */
621                         switch (ale->type) {
622                                 case ANIMTYPE_NLATRACK:
623                                 {
624                                         AnimData *adt = ale->adt;
625                                         NlaTrack *nlt = (NlaTrack *)ale->data;
626                                         
627                                         /* draw each strip in the track (if visible) */
628                                         int index = 1;
629                                         for (NlaStrip *strip = nlt->strips.first; strip; strip = strip->next, index++) {
630                                                 if (BKE_nlastrip_within_bounds(strip, v2d->cur.xmin, v2d->cur.xmax)) {
631                                                         const float xminc = strip->start + text_margin_x;
632                                                         const float xmaxc = strip->end + text_margin_x;
633
634                                                         /* draw the visualization of the strip */
635                                                         nla_draw_strip(snla, adt, nlt, strip, v2d, yminc, ymaxc);
636                                                         
637                                                         /* add the text for this strip to the cache */
638                                                         if (xminc < xmaxc) {
639                                                                 nla_draw_strip_text(adt, nlt, strip, index, v2d, xminc, xmaxc, yminc, ymaxc);
640                                                         }
641                                                         
642                                                         /* if transforming strips (only real reason for temp-metas currently), 
643                                                          * add to the cache the frame numbers of the strip's extents
644                                                          */
645                                                         if (strip->flag & NLASTRIP_FLAG_TEMP_META)
646                                                                 nla_draw_strip_frames_text(nlt, strip, v2d, yminc, ymaxc);
647                                                 }
648                                         }
649                                         break;
650                                 }
651                                 case ANIMTYPE_NLAACTION:
652                                 {
653                                         AnimData *adt = ale->adt;
654
655                                         unsigned int pos = add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
656                                         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
657
658                                         /* just draw a semi-shaded rect spanning the width of the viewable area if there's data,
659                                          * and a second darker rect within which we draw keyframe indicator dots if there's data
660                                          */
661                                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
662                                         glEnable(GL_BLEND);
663
664                                         /* get colors for drawing */
665                                         float color[4];
666                                         nla_action_get_color(adt, ale->data, color);
667                                         immUniformColor4fv(color);
668
669                                         /* draw slightly shifted up for greater separation from standard channels,
670                                          * but also slightly shorter for some more contrast when viewing the strips
671                                          */
672                                         immRectf(pos, v2d->cur.xmin, yminc + NLACHANNEL_SKIP, v2d->cur.xmax, ymaxc - NLACHANNEL_SKIP);
673                                         
674                                         /* draw 'embossed' lines above and below the strip for effect */
675                                         /* white base-lines */
676                                         glLineWidth(2.0f);
677                                         immUniformColor4f(1.0f, 1.0f, 1.0f, 0.3);
678                                         immBegin(PRIM_LINES, 4);
679                                         immVertex2f(pos, v2d->cur.xmin, yminc + NLACHANNEL_SKIP);
680                                         immVertex2f(pos, v2d->cur.xmax, yminc + NLACHANNEL_SKIP);
681                                         immVertex2f(pos, v2d->cur.xmin, ymaxc - NLACHANNEL_SKIP);
682                                         immVertex2f(pos, v2d->cur.xmax, ymaxc - NLACHANNEL_SKIP);
683                                         immEnd();
684
685                                         /* black top-lines */
686                                         glLineWidth(1.0f);
687                                         immUniformColor3f(0.0f, 0.0f, 0.0f);
688                                         immBegin(PRIM_LINES, 4);
689                                         immVertex2f(pos, v2d->cur.xmin, yminc + NLACHANNEL_SKIP);
690                                         immVertex2f(pos, v2d->cur.xmax, yminc + NLACHANNEL_SKIP);
691                                         immVertex2f(pos, v2d->cur.xmin, ymaxc - NLACHANNEL_SKIP);
692                                         immVertex2f(pos, v2d->cur.xmax, ymaxc - NLACHANNEL_SKIP);
693                                         immEnd();
694
695                                         /* TODO: these lines but better --^ */
696
697                                         immUnbindProgram();
698
699                                         /* draw keyframes in the action */
700                                         nla_action_draw_keyframes(adt, ale->data, y, yminc + NLACHANNEL_SKIP, ymaxc - NLACHANNEL_SKIP);
701
702                                         glDisable(GL_BLEND);
703                                         break;
704                                 }
705                         }
706                 }
707
708                 /* adjust y-position for next one */
709                 y -= NLACHANNEL_STEP(snla);
710         }
711         
712         /* free tempolary channels */
713         ANIM_animdata_freelist(&anim_data);
714 }
715
716 /* *********************************************** */
717 /* Channel List */
718
719 void draw_nla_channel_list(const bContext *C, bAnimContext *ac, ARegion *ar)
720 {
721         ListBase anim_data = {NULL, NULL};
722         bAnimListElem *ale;
723         
724         SpaceNla *snla = (SpaceNla *)ac->sl;
725         View2D *v2d = &ar->v2d;
726         float y = 0.0f;
727         
728         /* build list of channels to draw */
729         int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);
730         size_t items = ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
731         
732         /* Update max-extent of channels here (taking into account scrollers):
733          *  - this is done to allow the channel list to be scrollable, but must be done here
734          *    to avoid regenerating the list again and/or also because channels list is drawn first
735          *      - offset of NLACHANNEL_HEIGHT*2 is added to the height of the channels, as first is for 
736          *        start of list offset, and the second is as a correction for the scrollers.
737          */
738         int height = ((items * NLACHANNEL_STEP(snla)) + (NLACHANNEL_HEIGHT(snla) * 2));
739         /* don't use totrect set, as the width stays the same 
740          * (NOTE: this is ok here, the configuration is pretty straightforward) 
741          */
742         v2d->tot.ymin = (float)(-height);
743         /* need to do a view-sync here, so that the keys area doesn't jump around (it must copy this) */
744         UI_view2d_sync(NULL, ac->sa, v2d, V2D_LOCK_COPY);
745         
746         /* draw channels */
747         {   /* first pass: just the standard GL-drawing for backdrop + text */
748                 size_t channel_index = 0;
749                 
750                 y = (float)(-NLACHANNEL_HEIGHT(snla));
751                 
752                 for (ale = anim_data.first; ale; ale = ale->next) {
753                         float yminc = (float)(y -  NLACHANNEL_HEIGHT_HALF(snla));
754                         float ymaxc = (float)(y +  NLACHANNEL_HEIGHT_HALF(snla));
755                         
756                         /* check if visible */
757                         if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
758                             IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
759                         {
760                                 /* draw all channels using standard channel-drawing API */
761                                 ANIM_channel_draw(ac, ale, yminc, ymaxc, channel_index);
762                         }
763                         
764                         /* adjust y-position for next one */
765                         y -= NLACHANNEL_STEP(snla);
766                         channel_index++;
767                 }
768         }
769         {   /* second pass: UI widgets */
770                 uiBlock *block = UI_block_begin(C, ar, __func__, UI_EMBOSS);
771                 size_t channel_index = 0;
772                 
773                 y = (float)(-NLACHANNEL_HEIGHT(snla));
774                 
775                 /* set blending again, as may not be set in previous step */
776                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
777                 glEnable(GL_BLEND);
778                 
779                 /* loop through channels, and set up drawing depending on their type  */
780                 for (ale = anim_data.first; ale; ale = ale->next) {
781                         const float yminc = (float)(y - NLACHANNEL_HEIGHT_HALF(snla));
782                         const float ymaxc = (float)(y + NLACHANNEL_HEIGHT_HALF(snla));
783                         
784                         /* check if visible */
785                         if (IN_RANGE(yminc, v2d->cur.ymin, v2d->cur.ymax) ||
786                             IN_RANGE(ymaxc, v2d->cur.ymin, v2d->cur.ymax) )
787                         {
788                                 /* draw all channels using standard channel-drawing API */
789                                 ANIM_channel_draw_widgets(C, ac, ale, block, yminc, ymaxc, channel_index);
790                         }
791                         
792                         /* adjust y-position for next one */
793                         y -= NLACHANNEL_STEP(snla);
794                         channel_index++;
795                 }
796                 
797                 UI_block_end(C, block);
798                 UI_block_draw(C, block);
799                 
800                 glDisable(GL_BLEND);
801         }
802         
803         /* free temporary channels */
804         ANIM_animdata_freelist(&anim_data);
805 }
806
807 /* *********************************************** */