Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / space_clip / clip_draw.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2011 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup spclip
22  */
23
24 #include "DNA_gpencil_types.h"
25 #include "DNA_movieclip_types.h"
26 #include "DNA_scene_types.h"
27
28 #include "MEM_guardedalloc.h"
29
30 #include "IMB_colormanagement.h"
31 #include "IMB_imbuf_types.h"
32 #include "IMB_imbuf.h"
33
34 #include "BLI_utildefines.h"
35 #include "BLI_math.h"
36 #include "BLI_string.h"
37 #include "BLI_math_base.h"
38 #include "BLI_rect.h"
39
40 #include "BKE_context.h"
41 #include "BKE_image.h"
42 #include "BKE_movieclip.h"
43 #include "BKE_tracking.h"
44
45 #include "ED_screen.h"
46 #include "ED_clip.h"
47 #include "ED_mask.h"
48 #include "ED_gpencil.h"
49
50 #include "BIF_glutil.h"
51
52 #include "GPU_immediate.h"
53 #include "GPU_immediate_util.h"
54 #include "GPU_matrix.h"
55 #include "GPU_state.h"
56
57 #include "WM_types.h"
58
59 #include "UI_interface.h"
60 #include "UI_resources.h"
61 #include "UI_view2d.h"
62
63 #include "BLF_api.h"
64
65 #include "clip_intern.h"  // own include
66
67 /*********************** main area drawing *************************/
68
69 static void draw_keyframe(
70     int frame, int cfra, int sfra, float framelen, int width, unsigned int pos)
71 {
72   int height = (frame == cfra) ? 22 : 10;
73   int x = (frame - sfra) * framelen;
74
75   if (width == 1) {
76     immBegin(GPU_PRIM_LINES, 2);
77     immVertex2i(pos, x, 0);
78     immVertex2i(pos, x, height * UI_DPI_FAC);
79     immEnd();
80   }
81   else {
82     immRecti(pos, x, 0, x + width, height * UI_DPI_FAC);
83   }
84 }
85
86 static int generic_track_get_markersnr(MovieTrackingTrack *track,
87                                        MovieTrackingPlaneTrack *plane_track)
88 {
89   if (track) {
90     return track->markersnr;
91   }
92   else if (plane_track) {
93     return plane_track->markersnr;
94   }
95
96   return 0;
97 }
98
99 static int generic_track_get_marker_framenr(MovieTrackingTrack *track,
100                                             MovieTrackingPlaneTrack *plane_track,
101                                             int marker_index)
102 {
103   if (track) {
104     BLI_assert(marker_index < track->markersnr);
105     return track->markers[marker_index].framenr;
106   }
107   else if (plane_track) {
108     BLI_assert(marker_index < plane_track->markersnr);
109     return plane_track->markers[marker_index].framenr;
110   }
111
112   return 0;
113 }
114
115 static bool generic_track_is_marker_enabled(MovieTrackingTrack *track,
116                                             MovieTrackingPlaneTrack *plane_track,
117                                             int marker_index)
118 {
119   if (track) {
120     BLI_assert(marker_index < track->markersnr);
121     return (track->markers[marker_index].flag & MARKER_DISABLED) == 0;
122   }
123   else if (plane_track) {
124     return true;
125   }
126
127   return false;
128 }
129
130 static bool generic_track_is_marker_keyframed(MovieTrackingTrack *track,
131                                               MovieTrackingPlaneTrack *plane_track,
132                                               int marker_index)
133 {
134   if (track) {
135     BLI_assert(marker_index < track->markersnr);
136     return (track->markers[marker_index].flag & MARKER_TRACKED) == 0;
137   }
138   else if (plane_track) {
139     BLI_assert(marker_index < plane_track->markersnr);
140     return (plane_track->markers[marker_index].flag & PLANE_MARKER_TRACKED) == 0;
141   }
142
143   return false;
144 }
145
146 static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Scene *scene)
147 {
148   float x;
149   int *points, totseg, i, a;
150   float sfra = SFRA, efra = EFRA, framelen = ar->winx / (efra - sfra + 1);
151   MovieTracking *tracking = &clip->tracking;
152   MovieTrackingObject *act_object = BKE_tracking_object_get_active(tracking);
153   MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
154   MovieTrackingPlaneTrack *act_plane_track = BKE_tracking_plane_track_get_active(&clip->tracking);
155   MovieTrackingReconstruction *reconstruction = BKE_tracking_get_active_reconstruction(tracking);
156
157   GPU_blend(true);
158   GPU_blend_set_func_separate(
159       GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
160
161   /* cache background */
162   ED_region_cache_draw_background(ar);
163
164   /* cached segments -- could be usefu lto debug caching strategies */
165   BKE_movieclip_get_cache_segments(clip, &sc->user, &totseg, &points);
166   ED_region_cache_draw_cached_segments(ar, totseg, points, sfra, efra);
167
168   uint pos = GPU_vertformat_attr_add(
169       immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
170   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
171
172   /* track */
173   if (act_track || act_plane_track) {
174     for (i = sfra - clip->start_frame + 1, a = 0; i <= efra - clip->start_frame + 1; i++) {
175       int framenr;
176       int markersnr = generic_track_get_markersnr(act_track, act_plane_track);
177
178       while (a < markersnr) {
179         int marker_framenr = generic_track_get_marker_framenr(act_track, act_plane_track, a);
180
181         if (marker_framenr >= i) {
182           break;
183         }
184
185         if (a < markersnr - 1 &&
186             generic_track_get_marker_framenr(act_track, act_plane_track, a + 1) > i) {
187           break;
188         }
189
190         a++;
191       }
192
193       a = min_ii(a, markersnr - 1);
194
195       if (generic_track_is_marker_enabled(act_track, act_plane_track, a)) {
196         framenr = generic_track_get_marker_framenr(act_track, act_plane_track, a);
197
198         if (framenr != i) {
199           immUniformColor4ub(128, 128, 0, 96);
200         }
201         else if (generic_track_is_marker_keyframed(act_track, act_plane_track, a)) {
202           immUniformColor4ub(255, 255, 0, 196);
203         }
204         else {
205           immUniformColor4ub(255, 255, 0, 96);
206         }
207
208         immRecti(pos,
209                  (i - sfra + clip->start_frame - 1) * framelen,
210                  0,
211                  (i - sfra + clip->start_frame) * framelen,
212                  4 * UI_DPI_FAC);
213       }
214     }
215   }
216
217   /* failed frames */
218   if (reconstruction->flag & TRACKING_RECONSTRUCTED) {
219     int n = reconstruction->camnr;
220     MovieReconstructedCamera *cameras = reconstruction->cameras;
221
222     immUniformColor4ub(255, 0, 0, 96);
223
224     for (i = sfra, a = 0; i <= efra; i++) {
225       bool ok = false;
226
227       while (a < n) {
228         if (cameras[a].framenr == i) {
229           ok = true;
230           break;
231         }
232         else if (cameras[a].framenr > i) {
233           break;
234         }
235
236         a++;
237       }
238
239       if (!ok) {
240         immRecti(pos,
241                  (i - sfra + clip->start_frame - 1) * framelen,
242                  0,
243                  (i - sfra + clip->start_frame) * framelen,
244                  8 * UI_DPI_FAC);
245       }
246     }
247   }
248
249   GPU_blend(false);
250
251   /* current frame */
252   x = (sc->user.framenr - sfra) / (efra - sfra + 1) * ar->winx;
253
254   immUniformThemeColor(TH_CFRAME);
255   immRecti(pos, x, 0, x + ceilf(framelen), 8 * UI_DPI_FAC);
256
257   immUnbindProgram();
258
259   ED_region_cache_draw_curfra_label(sc->user.framenr, x, 8.0f * UI_DPI_FAC);
260
261   pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
262   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
263
264   /* solver keyframes */
265   immUniformColor4ub(175, 255, 0, 255);
266   draw_keyframe(act_object->keyframe1 + clip->start_frame - 1, CFRA, sfra, framelen, 2, pos);
267   draw_keyframe(act_object->keyframe2 + clip->start_frame - 1, CFRA, sfra, framelen, 2, pos);
268
269   immUnbindProgram();
270
271   /* movie clip animation */
272   if ((sc->mode == SC_MODE_MASKEDIT) && sc->mask_info.mask) {
273     ED_mask_draw_frames(sc->mask_info.mask, ar, CFRA, sfra, efra);
274   }
275 }
276
277 static void draw_movieclip_notes(SpaceClip *sc, ARegion *ar)
278 {
279   MovieClip *clip = ED_space_clip_get_clip(sc);
280   MovieTracking *tracking = &clip->tracking;
281   char str[256] = {0};
282   bool full_redraw = false;
283
284   if (tracking->stats) {
285     BLI_strncpy(str, tracking->stats->message, sizeof(str));
286     full_redraw = true;
287   }
288   else {
289     if (sc->flag & SC_LOCK_SELECTION) {
290       strcpy(str, "Locked");
291     }
292   }
293
294   if (str[0]) {
295     float fill_color[4] = {0.0f, 0.0f, 0.0f, 0.6f};
296     ED_region_info_draw(ar, str, fill_color, full_redraw);
297   }
298 }
299
300 static void draw_movieclip_muted(ARegion *ar, int width, int height, float zoomx, float zoomy)
301 {
302   int x, y;
303
304   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
305   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
306
307   /* find window pixel coordinates of origin */
308   UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &x, &y);
309
310   immUniformColor3f(0.0f, 0.0f, 0.0f);
311   immRectf(pos, x, y, x + zoomx * width, y + zoomy * height);
312
313   immUnbindProgram();
314 }
315
316 static void draw_movieclip_buffer(const bContext *C,
317                                   SpaceClip *sc,
318                                   ARegion *ar,
319                                   ImBuf *ibuf,
320                                   int width,
321                                   int height,
322                                   float zoomx,
323                                   float zoomy)
324 {
325   MovieClip *clip = ED_space_clip_get_clip(sc);
326   int filter = GL_LINEAR;
327   int x, y;
328
329   /* find window pixel coordinates of origin */
330   UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &x, &y);
331
332   /* checkerboard for case alpha */
333   if (ibuf->planes == 32) {
334     GPU_blend(true);
335     GPU_blend_set_func_separate(
336         GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
337
338     imm_draw_box_checker_2d(x, y, x + zoomx * ibuf->x, y + zoomy * ibuf->y);
339   }
340
341   /* non-scaled proxy shouldn't use filtering */
342   if ((clip->flag & MCLIP_USE_PROXY) == 0 ||
343       ELEM(sc->user.render_size, MCLIP_PROXY_RENDER_SIZE_FULL, MCLIP_PROXY_RENDER_SIZE_100)) {
344     filter = GL_NEAREST;
345   }
346
347   ED_draw_imbuf_ctx(C, ibuf, x, y, filter, zoomx * width / ibuf->x, zoomy * height / ibuf->y);
348
349   if (ibuf->planes == 32) {
350     GPU_blend(false);
351   }
352
353   if (sc->flag & SC_SHOW_METADATA) {
354     rctf frame;
355     BLI_rctf_init(&frame, 0.0f, ibuf->x, 0.0f, ibuf->y);
356     ED_region_image_metadata_draw(
357         x, y, ibuf, &frame, zoomx * width / ibuf->x, zoomy * height / ibuf->y);
358   }
359 }
360
361 static void draw_stabilization_border(
362     SpaceClip *sc, ARegion *ar, int width, int height, float zoomx, float zoomy)
363 {
364   int x, y;
365   MovieClip *clip = ED_space_clip_get_clip(sc);
366
367   /* find window pixel coordinates of origin */
368   UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &x, &y);
369
370   /* draw boundary border for frame if stabilization is enabled */
371   if (sc->flag & SC_SHOW_STABLE && clip->tracking.stabilization.flag & TRACKING_2D_STABILIZATION) {
372     const uint shdr_pos = GPU_vertformat_attr_add(
373         immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
374
375     /* Exclusive OR allows to get orig value when second operand is 0,
376      * and negative of orig value when second operand is 1. */
377     glEnable(GL_COLOR_LOGIC_OP);
378     glLogicOp(GL_XOR);
379
380     GPU_matrix_push();
381     GPU_matrix_translate_2f(x, y);
382
383     GPU_matrix_scale_2f(zoomx, zoomy);
384     GPU_matrix_mul(sc->stabmat);
385
386     immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
387
388     float viewport_size[4];
389     GPU_viewport_size_get_f(viewport_size);
390     immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
391
392     immUniform1i("colors_len", 0); /* "simple" mode */
393     immUniformColor4f(1.0f, 1.0f, 1.0f, 0.0f);
394     immUniform1f("dash_width", 6.0f);
395     immUniform1f("dash_factor", 0.5f);
396
397     imm_draw_box_wire_2d(shdr_pos, 0.0f, 0.0f, width, height);
398
399     immUnbindProgram();
400
401     GPU_matrix_pop();
402
403     glDisable(GL_COLOR_LOGIC_OP);
404   }
405 }
406
407 static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackingTrack *track)
408 {
409 #define MAX_STATIC_PATH 64
410   int count = sc->path_length;
411   int i, a, b, curindex = -1;
412   float path_static[(MAX_STATIC_PATH + 1) * 2][2];
413   float(*path)[2];
414   int tiny = sc->flag & SC_SHOW_TINY_MARKER, framenr, start_frame;
415   MovieTrackingMarker *marker;
416
417   if (count == 0) {
418     return;
419   }
420
421   start_frame = framenr = ED_space_clip_get_clip_frame_number(sc);
422
423   marker = BKE_tracking_marker_get(track, framenr);
424   if (marker->framenr != framenr || marker->flag & MARKER_DISABLED) {
425     return;
426   }
427
428   if (count < MAX_STATIC_PATH) {
429     path = path_static;
430   }
431   else {
432     path = MEM_mallocN(sizeof(*path) * (count + 1) * 2, "path");
433   }
434
435   a = count;
436   i = framenr - 1;
437   while (i >= framenr - count) {
438     marker = BKE_tracking_marker_get(track, i);
439
440     if (!marker || marker->flag & MARKER_DISABLED) {
441       break;
442     }
443
444     if (marker->framenr == i) {
445       add_v2_v2v2(path[--a], marker->pos, track->offset);
446       ED_clip_point_undistorted_pos(sc, path[a], path[a]);
447
448       if (marker->framenr == start_frame) {
449         curindex = a;
450       }
451     }
452     else {
453       break;
454     }
455
456     i--;
457   }
458
459   b = count;
460   i = framenr;
461   while (i <= framenr + count) {
462     marker = BKE_tracking_marker_get(track, i);
463
464     if (!marker || marker->flag & MARKER_DISABLED) {
465       break;
466     }
467
468     if (marker->framenr == i) {
469       if (marker->framenr == start_frame) {
470         curindex = b;
471       }
472
473       add_v2_v2v2(path[b++], marker->pos, track->offset);
474       ED_clip_point_undistorted_pos(sc, path[b - 1], path[b - 1]);
475     }
476     else {
477       break;
478     }
479
480     i++;
481   }
482
483   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
484
485   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
486
487   if (!tiny) {
488     immUniformThemeColor(TH_MARKER_OUTLINE);
489
490     if (TRACK_VIEW_SELECTED(sc, track)) {
491       if ((b - a - 1) >= 1) {
492         GPU_point_size(5.0f);
493
494         immBegin(GPU_PRIM_POINTS, b - a - 1);
495
496         for (i = a; i < b; i++) {
497           if (i != curindex) {
498             immVertex2f(pos, path[i][0], path[i][1]);
499           }
500         }
501
502         immEnd();
503       }
504     }
505
506     if ((b - a) >= 2) {
507       GPU_line_width(3.0f);
508
509       immBegin(GPU_PRIM_LINE_STRIP, b - a);
510
511       for (i = a; i < b; i++) {
512         immVertex2f(pos, path[i][0], path[i][1]);
513       }
514
515       immEnd();
516     }
517   }
518
519   if (TRACK_VIEW_SELECTED(sc, track)) {
520     GPU_point_size(3.0f);
521
522     if ((curindex - a) >= 1) {
523       immUniformThemeColor(TH_PATH_BEFORE);
524
525       immBegin(GPU_PRIM_POINTS, curindex - a);
526
527       for (i = a; i < curindex; i++) {
528         immVertex2f(pos, path[i][0], path[i][1]);
529       }
530
531       immEnd();
532     }
533
534     if ((b - curindex - 1) >= 1) {
535       immUniformThemeColor(TH_PATH_AFTER);
536
537       immBegin(GPU_PRIM_POINTS, b - curindex - 1);
538
539       for (i = curindex + 1; i < b; i++) {
540         immVertex2f(pos, path[i][0], path[i][1]);
541       }
542
543       immEnd();
544     }
545   }
546
547   GPU_line_width(1);
548
549   if ((curindex - a + 1) >= 2) {
550     immUniformThemeColor(TH_PATH_BEFORE);
551
552     immBegin(GPU_PRIM_LINE_STRIP, curindex - a + 1);
553
554     for (i = a; i <= curindex; i++) {
555       immVertex2f(pos, path[i][0], path[i][1]);
556     }
557
558     immEnd();
559   }
560
561   if ((b - curindex) >= 2) {
562     immUniformThemeColor(TH_PATH_AFTER);
563
564     immBegin(GPU_PRIM_LINE_STRIP, b - curindex);
565
566     for (i = curindex; i < b; i++) {
567       immVertex2f(pos, path[i][0], path[i][1]);
568     }
569
570     immEnd();
571   }
572
573   immUnbindProgram();
574
575   if (path != path_static) {
576     MEM_freeN(path);
577   }
578 #undef MAX_STATIC_PATH
579 }
580
581 static void draw_marker_outline(SpaceClip *sc,
582                                 MovieTrackingTrack *track,
583                                 MovieTrackingMarker *marker,
584                                 const float marker_pos[2],
585                                 int width,
586                                 int height,
587                                 unsigned int position)
588 {
589   int tiny = sc->flag & SC_SHOW_TINY_MARKER;
590   bool show_search = false;
591   float px[2];
592
593   px[0] = 1.0f / width / sc->zoom;
594   px[1] = 1.0f / height / sc->zoom;
595
596   GPU_line_width(tiny ? 1.0f : 3.0f);
597
598   immUniformThemeColor(TH_MARKER_OUTLINE);
599
600   if ((marker->flag & MARKER_DISABLED) == 0) {
601     float pos[2];
602     float p[2];
603
604     add_v2_v2v2(pos, marker->pos, track->offset);
605
606     ED_clip_point_undistorted_pos(sc, pos, pos);
607
608     sub_v2_v2v2(p, pos, marker_pos);
609
610     if (isect_point_quad_v2(p,
611                             marker->pattern_corners[0],
612                             marker->pattern_corners[1],
613                             marker->pattern_corners[2],
614                             marker->pattern_corners[3])) {
615       GPU_point_size(tiny ? 3.0f : 4.0f);
616
617       immBegin(GPU_PRIM_POINTS, 1);
618       immVertex2f(position, pos[0], pos[1]);
619       immEnd();
620     }
621     else {
622       immBegin(GPU_PRIM_LINES, 8);
623
624       immVertex2f(position, pos[0] + px[0] * 2, pos[1]);
625       immVertex2f(position, pos[0] + px[0] * 8, pos[1]);
626
627       immVertex2f(position, pos[0] - px[0] * 2, pos[1]);
628       immVertex2f(position, pos[0] - px[0] * 8, pos[1]);
629
630       immVertex2f(position, pos[0], pos[1] - px[1] * 2);
631       immVertex2f(position, pos[0], pos[1] - px[1] * 8);
632
633       immVertex2f(position, pos[0], pos[1] + px[1] * 2);
634       immVertex2f(position, pos[0], pos[1] + px[1] * 8);
635
636       immEnd();
637     }
638   }
639
640   /* pattern and search outline */
641   GPU_matrix_push();
642   GPU_matrix_translate_2fv(marker_pos);
643
644   if (sc->flag & SC_SHOW_MARKER_PATTERN) {
645     immBegin(GPU_PRIM_LINE_LOOP, 4);
646     immVertex2fv(position, marker->pattern_corners[0]);
647     immVertex2fv(position, marker->pattern_corners[1]);
648     immVertex2fv(position, marker->pattern_corners[2]);
649     immVertex2fv(position, marker->pattern_corners[3]);
650     immEnd();
651   }
652
653   show_search = (TRACK_VIEW_SELECTED(sc, track) && ((marker->flag & MARKER_DISABLED) == 0 ||
654                                                     (sc->flag & SC_SHOW_MARKER_PATTERN) == 0)) !=
655                 0;
656
657   if (sc->flag & SC_SHOW_MARKER_SEARCH && show_search) {
658     imm_draw_box_wire_2d(position,
659                          marker->search_min[0],
660                          marker->search_min[1],
661                          marker->search_max[0],
662                          marker->search_max[1]);
663   }
664
665   GPU_matrix_pop();
666 }
667
668 static void track_colors(MovieTrackingTrack *track, int act, float col[3], float scol[3])
669 {
670   if (track->flag & TRACK_CUSTOMCOLOR) {
671     if (act) {
672       UI_GetThemeColor3fv(TH_ACT_MARKER, scol);
673     }
674     else {
675       copy_v3_v3(scol, track->color);
676     }
677
678     mul_v3_v3fl(col, track->color, 0.5f);
679   }
680   else {
681     UI_GetThemeColor3fv(TH_MARKER, col);
682
683     if (act) {
684       UI_GetThemeColor3fv(TH_ACT_MARKER, scol);
685     }
686     else {
687       UI_GetThemeColor3fv(TH_SEL_MARKER, scol);
688     }
689   }
690 }
691
692 static void draw_marker_areas(SpaceClip *sc,
693                               MovieTrackingTrack *track,
694                               MovieTrackingMarker *marker,
695                               const float marker_pos[2],
696                               int width,
697                               int height,
698                               int act,
699                               int sel,
700                               const uint shdr_pos)
701 {
702   int tiny = sc->flag & SC_SHOW_TINY_MARKER;
703   bool show_search = false;
704   float col[3], scol[3];
705   float px[2];
706
707   track_colors(track, act, col, scol);
708
709   px[0] = 1.0f / width / sc->zoom;
710   px[1] = 1.0f / height / sc->zoom;
711
712   GPU_line_width(1.0f);
713
714   /* Since we are switching solid and dashed lines in rather complex logic here,
715    * just always go with dashed shader. */
716   immUnbindProgram();
717
718   immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
719
720   float viewport_size[4];
721   GPU_viewport_size_get_f(viewport_size);
722   immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
723
724   immUniform1i("colors_len", 0); /* "simple" mode */
725
726   /* marker position and offset position */
727   if ((track->flag & SELECT) == sel && (marker->flag & MARKER_DISABLED) == 0) {
728     float pos[2], p[2];
729
730     if (track->flag & TRACK_LOCKED) {
731       if (act) {
732         immUniformThemeColor(TH_ACT_MARKER);
733       }
734       else if (track->flag & SELECT) {
735         immUniformThemeColorShade(TH_LOCK_MARKER, 64);
736       }
737       else {
738         immUniformThemeColor(TH_LOCK_MARKER);
739       }
740     }
741     else {
742       immUniformColor3fv((track->flag & SELECT) ? scol : col);
743     }
744
745     add_v2_v2v2(pos, marker->pos, track->offset);
746     ED_clip_point_undistorted_pos(sc, pos, pos);
747
748     sub_v2_v2v2(p, pos, marker_pos);
749
750     if (isect_point_quad_v2(p,
751                             marker->pattern_corners[0],
752                             marker->pattern_corners[1],
753                             marker->pattern_corners[2],
754                             marker->pattern_corners[3])) {
755       GPU_point_size(tiny ? 1.0f : 2.0f);
756
757       immUniform1f("dash_factor", 2.0f); /* Solid "line" */
758
759       immBegin(GPU_PRIM_POINTS, 1);
760       immVertex2f(shdr_pos, pos[0], pos[1]);
761       immEnd();
762     }
763     else {
764       immUniform1f("dash_factor", 2.0f); /* Solid line */
765
766       immBegin(GPU_PRIM_LINES, 8);
767
768       immVertex2f(shdr_pos, pos[0] + px[0] * 3, pos[1]);
769       immVertex2f(shdr_pos, pos[0] + px[0] * 7, pos[1]);
770
771       immVertex2f(shdr_pos, pos[0] - px[0] * 3, pos[1]);
772       immVertex2f(shdr_pos, pos[0] - px[0] * 7, pos[1]);
773
774       immVertex2f(shdr_pos, pos[0], pos[1] - px[1] * 3);
775       immVertex2f(shdr_pos, pos[0], pos[1] - px[1] * 7);
776
777       immVertex2f(shdr_pos, pos[0], pos[1] + px[1] * 3);
778       immVertex2f(shdr_pos, pos[0], pos[1] + px[1] * 7);
779
780       immEnd();
781
782       immUniformColor4f(1.0f, 1.0f, 1.0f, 0.0f);
783       immUniform1f("dash_width", 6.0f);
784       immUniform1f("dash_factor", 0.5f);
785
786       glEnable(GL_COLOR_LOGIC_OP);
787       glLogicOp(GL_XOR);
788
789       immBegin(GPU_PRIM_LINES, 2);
790       immVertex2fv(shdr_pos, pos);
791       immVertex2fv(shdr_pos, marker_pos);
792       immEnd();
793
794       glDisable(GL_COLOR_LOGIC_OP);
795     }
796   }
797
798   /* pattern */
799   GPU_matrix_push();
800   GPU_matrix_translate_2fv(marker_pos);
801
802   if (track->flag & TRACK_LOCKED) {
803     if (act) {
804       immUniformThemeColor(TH_ACT_MARKER);
805     }
806     else if (track->pat_flag & SELECT) {
807       immUniformThemeColorShade(TH_LOCK_MARKER, 64);
808     }
809     else {
810       immUniformThemeColor(TH_LOCK_MARKER);
811     }
812   }
813   else if (marker->flag & MARKER_DISABLED) {
814     if (act) {
815       immUniformThemeColor(TH_ACT_MARKER);
816     }
817     else if (track->pat_flag & SELECT) {
818       immUniformThemeColorShade(TH_DIS_MARKER, 128);
819     }
820     else {
821       immUniformThemeColor(TH_DIS_MARKER);
822     }
823   }
824   else {
825     immUniformColor3fv((track->pat_flag & SELECT) ? scol : col);
826   }
827
828   if (tiny) {
829     immUniform1f("dash_width", 6.0f);
830     immUniform1f("dash_factor", 0.5f);
831   }
832   else {
833     immUniform1f("dash_factor", 2.0f); /* Solid line */
834   }
835
836   if ((track->pat_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_PATTERN)) {
837     immBegin(GPU_PRIM_LINE_LOOP, 4);
838     immVertex2fv(shdr_pos, marker->pattern_corners[0]);
839     immVertex2fv(shdr_pos, marker->pattern_corners[1]);
840     immVertex2fv(shdr_pos, marker->pattern_corners[2]);
841     immVertex2fv(shdr_pos, marker->pattern_corners[3]);
842     immEnd();
843   }
844
845   /* search */
846   show_search = (TRACK_VIEW_SELECTED(sc, track) && ((marker->flag & MARKER_DISABLED) == 0 ||
847                                                     (sc->flag & SC_SHOW_MARKER_PATTERN) == 0)) !=
848                 0;
849
850   if ((track->search_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_SEARCH) && show_search) {
851     imm_draw_box_wire_2d(shdr_pos,
852                          marker->search_min[0],
853                          marker->search_min[1],
854                          marker->search_max[0],
855                          marker->search_max[1]);
856   }
857
858   GPU_matrix_pop();
859
860   /* Restore default shader */
861   immUnbindProgram();
862
863   const uint pos = GPU_vertformat_attr_add(
864       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
865   BLI_assert(pos == shdr_pos);
866   UNUSED_VARS_NDEBUG(pos);
867
868   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
869 }
870
871 static float get_shortest_pattern_side(MovieTrackingMarker *marker)
872 {
873   int i, next;
874   float len_sq = FLT_MAX;
875
876   for (i = 0; i < 4; i++) {
877     float cur_len;
878
879     next = (i + 1) % 4;
880
881     cur_len = len_squared_v2v2(marker->pattern_corners[i], marker->pattern_corners[next]);
882
883     len_sq = min_ff(cur_len, len_sq);
884   }
885
886   return sqrtf(len_sq);
887 }
888
889 static void draw_marker_slide_square(
890     float x, float y, float dx, float dy, int outline, float px[2], unsigned int pos)
891 {
892   float tdx, tdy;
893
894   tdx = dx;
895   tdy = dy;
896
897   if (outline) {
898     tdx += px[0];
899     tdy += px[1];
900   }
901
902   immRectf(pos, x - tdx, y - tdy, x + tdx, y + tdy);
903 }
904
905 static void draw_marker_slide_triangle(
906     float x, float y, float dx, float dy, int outline, float px[2], unsigned int pos)
907 {
908   float tdx, tdy;
909
910   tdx = dx * 2.0f;
911   tdy = dy * 2.0f;
912
913   if (outline) {
914     tdx += px[0];
915     tdy += px[1];
916   }
917
918   immBegin(GPU_PRIM_TRIS, 3);
919   immVertex2f(pos, x, y);
920   immVertex2f(pos, x - tdx, y);
921   immVertex2f(pos, x, y + tdy);
922   immEnd();
923 }
924
925 static void draw_marker_slide_zones(SpaceClip *sc,
926                                     MovieTrackingTrack *track,
927                                     MovieTrackingMarker *marker,
928                                     const float marker_pos[2],
929                                     int outline,
930                                     int sel,
931                                     int act,
932                                     int width,
933                                     int height,
934                                     unsigned int pos)
935 {
936   float dx, dy, patdx, patdy, searchdx, searchdy;
937   int tiny = sc->flag & SC_SHOW_TINY_MARKER;
938   float col[3], scol[3], px[2], side;
939
940   if ((tiny && outline) || (marker->flag & MARKER_DISABLED)) {
941     return;
942   }
943
944   if (!TRACK_VIEW_SELECTED(sc, track) || track->flag & TRACK_LOCKED) {
945     return;
946   }
947
948   track_colors(track, act, col, scol);
949
950   if (outline) {
951     immUniformThemeColor(TH_MARKER_OUTLINE);
952   }
953
954   GPU_matrix_push();
955   GPU_matrix_translate_2fv(marker_pos);
956
957   dx = 6.0f / width / sc->zoom;
958   dy = 6.0f / height / sc->zoom;
959
960   side = get_shortest_pattern_side(marker);
961   patdx = min_ff(dx * 2.0f / 3.0f, side / 6.0f) * UI_DPI_FAC;
962   patdy = min_ff(dy * 2.0f / 3.0f, side * width / height / 6.0f) * UI_DPI_FAC;
963
964   searchdx = min_ff(dx, (marker->search_max[0] - marker->search_min[0]) / 6.0f) * UI_DPI_FAC;
965   searchdy = min_ff(dy, (marker->search_max[1] - marker->search_min[1]) / 6.0f) * UI_DPI_FAC;
966
967   px[0] = 1.0f / sc->zoom / width / sc->scale;
968   px[1] = 1.0f / sc->zoom / height / sc->scale;
969
970   if ((sc->flag & SC_SHOW_MARKER_SEARCH) && ((track->search_flag & SELECT) == sel || outline)) {
971     if (!outline) {
972       immUniformColor3fv((track->search_flag & SELECT) ? scol : col);
973     }
974
975     /* search offset square */
976     draw_marker_slide_square(
977         marker->search_min[0], marker->search_max[1], searchdx, searchdy, outline, px, pos);
978
979     /* search re-sizing triangle */
980     draw_marker_slide_triangle(
981         marker->search_max[0], marker->search_min[1], searchdx, searchdy, outline, px, pos);
982   }
983
984   if ((sc->flag & SC_SHOW_MARKER_PATTERN) && ((track->pat_flag & SELECT) == sel || outline)) {
985     int i;
986     float pat_min[2], pat_max[2];
987     /*      float dx = 12.0f / width, dy = 12.0f / height;*/ /* XXX UNUSED */
988     float tilt_ctrl[2];
989
990     if (!outline) {
991       immUniformColor3fv((track->pat_flag & SELECT) ? scol : col);
992     }
993
994     /* pattern's corners sliding squares */
995     for (i = 0; i < 4; i++) {
996       draw_marker_slide_square(marker->pattern_corners[i][0],
997                                marker->pattern_corners[i][1],
998                                patdx / 1.5f,
999                                patdy / 1.5f,
1000                                outline,
1001                                px,
1002                                pos);
1003     }
1004
1005     /* ** sliders to control overall pattern  ** */
1006     add_v2_v2v2(tilt_ctrl, marker->pattern_corners[1], marker->pattern_corners[2]);
1007
1008     BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
1009
1010     GPU_line_width(outline ? 3.0f : 1.0f);
1011
1012     immBegin(GPU_PRIM_LINES, 2);
1013     immVertex2f(pos, 0.0f, 0.0f);
1014     immVertex2fv(pos, tilt_ctrl);
1015     immEnd();
1016
1017     /* slider to control pattern tilt */
1018     draw_marker_slide_square(tilt_ctrl[0], tilt_ctrl[1], patdx, patdy, outline, px, pos);
1019   }
1020
1021   GPU_matrix_pop();
1022 }
1023
1024 static void draw_marker_texts(SpaceClip *sc,
1025                               MovieTrackingTrack *track,
1026                               MovieTrackingMarker *marker,
1027                               const float marker_pos[2],
1028                               int act,
1029                               int width,
1030                               int height,
1031                               float zoomx,
1032                               float zoomy)
1033 {
1034   char str[128] = {0}, state[64] = {0};
1035   float dx = 0.0f, dy = 0.0f, fontsize, pos[3];
1036   uiStyle *style = U.uistyles.first;
1037   int fontid = style->widget.uifont_id;
1038
1039   if (!TRACK_VIEW_SELECTED(sc, track)) {
1040     return;
1041   }
1042
1043   BLF_size(fontid, 11.0f * U.pixelsize, U.dpi);
1044   fontsize = BLF_height_max(fontid);
1045
1046   if (marker->flag & MARKER_DISABLED) {
1047     if (act) {
1048       UI_FontThemeColor(fontid, TH_ACT_MARKER);
1049     }
1050     else {
1051       unsigned char color[4];
1052       UI_GetThemeColorShade4ubv(TH_DIS_MARKER, 128, color);
1053       BLF_color4ubv(fontid, color);
1054     }
1055   }
1056   else {
1057     UI_FontThemeColor(fontid, act ? TH_ACT_MARKER : TH_SEL_MARKER);
1058   }
1059
1060   if ((sc->flag & SC_SHOW_MARKER_SEARCH) &&
1061       ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0)) {
1062     dx = marker->search_min[0];
1063     dy = marker->search_min[1];
1064   }
1065   else if (sc->flag & SC_SHOW_MARKER_PATTERN) {
1066     float pat_min[2], pat_max[2];
1067
1068     BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
1069     dx = pat_min[0];
1070     dy = pat_min[1];
1071   }
1072
1073   pos[0] = (marker_pos[0] + dx) * width;
1074   pos[1] = (marker_pos[1] + dy) * height;
1075   pos[2] = 0.0f;
1076
1077   mul_m4_v3(sc->stabmat, pos);
1078
1079   pos[0] = pos[0] * zoomx;
1080   pos[1] = pos[1] * zoomy - fontsize;
1081
1082   if (marker->flag & MARKER_DISABLED) {
1083     strcpy(state, "disabled");
1084   }
1085   else if (marker->framenr != ED_space_clip_get_clip_frame_number(sc)) {
1086     strcpy(state, "estimated");
1087   }
1088   else if (marker->flag & MARKER_TRACKED) {
1089     strcpy(state, "tracked");
1090   }
1091   else {
1092     strcpy(state, "keyframed");
1093   }
1094
1095   if (state[0]) {
1096     BLI_snprintf(str, sizeof(str), "%s: %s", track->name, state);
1097   }
1098   else {
1099     BLI_strncpy(str, track->name, sizeof(str));
1100   }
1101
1102   BLF_position(fontid, pos[0], pos[1], 0.0f);
1103   BLF_draw(fontid, str, sizeof(str));
1104   pos[1] -= fontsize;
1105
1106   if (track->flag & TRACK_HAS_BUNDLE) {
1107     BLI_snprintf(str, sizeof(str), "Average error: %.3f", track->error);
1108     BLF_position(fontid, pos[0], pos[1], 0.0f);
1109     BLF_draw(fontid, str, sizeof(str));
1110     pos[1] -= fontsize;
1111   }
1112
1113   if (track->flag & TRACK_LOCKED) {
1114     BLF_position(fontid, pos[0], pos[1], 0.0f);
1115     BLF_draw(fontid, "locked", 6);
1116   }
1117 }
1118
1119 static void plane_track_colors(bool is_active, float color[3], float selected_color[3])
1120 {
1121   UI_GetThemeColor3fv(TH_MARKER, color);
1122
1123   UI_GetThemeColor3fv(is_active ? TH_ACT_MARKER : TH_SEL_MARKER, selected_color);
1124 }
1125
1126 static void getArrowEndPoint(const int width,
1127                              const int height,
1128                              const float zoom,
1129                              const float start_corner[2],
1130                              const float end_corner[2],
1131                              float end_point[2])
1132 {
1133   float direction[2];
1134   float max_length;
1135
1136   sub_v2_v2v2(direction, end_corner, start_corner);
1137
1138   direction[0] *= width;
1139   direction[1] *= height;
1140   max_length = normalize_v2(direction);
1141   mul_v2_fl(direction, min_ff(32.0f / zoom, max_length));
1142   direction[0] /= width;
1143   direction[1] /= height;
1144
1145   add_v2_v2v2(end_point, start_corner, direction);
1146 }
1147
1148 static void homogeneous_2d_to_gl_matrix(/*const*/ float matrix[3][3], float gl_matrix[4][4])
1149 {
1150   gl_matrix[0][0] = matrix[0][0];
1151   gl_matrix[0][1] = matrix[0][1];
1152   gl_matrix[0][2] = 0.0f;
1153   gl_matrix[0][3] = matrix[0][2];
1154
1155   gl_matrix[1][0] = matrix[1][0];
1156   gl_matrix[1][1] = matrix[1][1];
1157   gl_matrix[1][2] = 0.0f;
1158   gl_matrix[1][3] = matrix[1][2];
1159
1160   gl_matrix[2][0] = 0.0f;
1161   gl_matrix[2][1] = 0.0f;
1162   gl_matrix[2][2] = 1.0f;
1163   gl_matrix[2][3] = 0.0f;
1164
1165   gl_matrix[3][0] = matrix[2][0];
1166   gl_matrix[3][1] = matrix[2][1];
1167   gl_matrix[3][2] = 0.0f;
1168   gl_matrix[3][3] = matrix[2][2];
1169 }
1170
1171 static void draw_plane_marker_image(Scene *scene,
1172                                     MovieTrackingPlaneTrack *plane_track,
1173                                     MovieTrackingPlaneMarker *plane_marker)
1174 {
1175   Image *image = plane_track->image;
1176   ImBuf *ibuf;
1177   void *lock;
1178
1179   if (image == NULL) {
1180     return;
1181   }
1182
1183   ibuf = BKE_image_acquire_ibuf(image, NULL, &lock);
1184
1185   if (ibuf) {
1186     unsigned char *display_buffer;
1187     void *cache_handle;
1188
1189     if (image->flag & IMA_VIEW_AS_RENDER) {
1190       display_buffer = IMB_display_buffer_acquire(
1191           ibuf, &scene->view_settings, &scene->display_settings, &cache_handle);
1192     }
1193     else {
1194       display_buffer = IMB_display_buffer_acquire(
1195           ibuf, NULL, &scene->display_settings, &cache_handle);
1196     }
1197
1198     if (display_buffer) {
1199       GLuint texid;
1200       float frame_corners[4][2] = {{0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f}};
1201       float perspective_matrix[3][3];
1202       float gl_matrix[4][4];
1203       bool transparent = false;
1204       BKE_tracking_homography_between_two_quads(
1205           frame_corners, plane_marker->corners, perspective_matrix);
1206
1207       homogeneous_2d_to_gl_matrix(perspective_matrix, gl_matrix);
1208
1209       if (plane_track->image_opacity != 1.0f || ibuf->planes == 32) {
1210         transparent = true;
1211         GPU_blend(true);
1212         GPU_blend_set_func_separate(
1213             GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
1214       }
1215
1216       glGenTextures(1, (GLuint *)&texid);
1217
1218       glActiveTexture(GL_TEXTURE0);
1219       glBindTexture(GL_TEXTURE_2D, texid);
1220
1221       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1222       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1223
1224       glTexImage2D(GL_TEXTURE_2D,
1225                    0,
1226                    GL_RGBA8,
1227                    ibuf->x,
1228                    ibuf->y,
1229                    0,
1230                    GL_RGBA,
1231                    GL_UNSIGNED_BYTE,
1232                    display_buffer);
1233
1234       GPU_matrix_push();
1235       GPU_matrix_mul(gl_matrix);
1236
1237       GPUVertFormat *imm_format = immVertexFormat();
1238       uint pos = GPU_vertformat_attr_add(imm_format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1239       uint texCoord = GPU_vertformat_attr_add(
1240           imm_format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1241
1242       immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_COLOR);
1243       immUniformColor4f(1.0f, 1.0f, 1.0f, plane_track->image_opacity);
1244       immUniform1i("image", 0);
1245
1246       immBegin(GPU_PRIM_TRI_FAN, 4);
1247
1248       immAttr2f(texCoord, 0.0f, 0.0f);
1249       immVertex2f(pos, 0.0f, 0.0f);
1250
1251       immAttr2f(texCoord, 1.0f, 0.0f);
1252       immVertex2f(pos, 1.0f, 0.0f);
1253
1254       immAttr2f(texCoord, 1.0f, 1.0f);
1255       immVertex2f(pos, 1.0f, 1.0f);
1256
1257       immAttr2f(texCoord, 0.0f, 1.0f);
1258       immVertex2f(pos, 0.0f, 1.0f);
1259
1260       immEnd();
1261
1262       immUnbindProgram();
1263
1264       GPU_matrix_pop();
1265
1266       glBindTexture(GL_TEXTURE_2D, 0);
1267
1268       if (transparent) {
1269         GPU_blend(false);
1270       }
1271     }
1272
1273     IMB_display_buffer_release(cache_handle);
1274   }
1275
1276   BKE_image_release_ibuf(image, ibuf, lock);
1277 }
1278
1279 static void draw_plane_marker_ex(SpaceClip *sc,
1280                                  Scene *scene,
1281                                  MovieTrackingPlaneTrack *plane_track,
1282                                  MovieTrackingPlaneMarker *plane_marker,
1283                                  bool is_active_track,
1284                                  bool draw_outline,
1285                                  int width,
1286                                  int height)
1287 {
1288   bool tiny = (sc->flag & SC_SHOW_TINY_MARKER) != 0;
1289   bool is_selected_track = (plane_track->flag & SELECT) != 0;
1290   const bool has_image = plane_track->image != NULL &&
1291                          BKE_image_has_ibuf(plane_track->image, NULL);
1292   const bool draw_plane_quad = !has_image || plane_track->image_opacity == 0.0f;
1293   float px[2];
1294   float color[3], selected_color[3];
1295
1296   px[0] = 1.0f / width / sc->zoom;
1297   px[1] = 1.0f / height / sc->zoom;
1298
1299   /* Draw image */
1300   if (draw_outline == false) {
1301     draw_plane_marker_image(scene, plane_track, plane_marker);
1302   }
1303
1304   if (draw_plane_quad || is_selected_track) {
1305     const uint shdr_pos = GPU_vertformat_attr_add(
1306         immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1307
1308     immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
1309
1310     float viewport_size[4];
1311     GPU_viewport_size_get_f(viewport_size);
1312     immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
1313
1314     immUniform1i("colors_len", 0); /* "simple" mode */
1315
1316     if (draw_plane_quad) {
1317       const bool stipple = !draw_outline && tiny;
1318       const bool thick = draw_outline && !tiny;
1319
1320       GPU_line_width(thick ? 3.0f : 1.0f);
1321
1322       if (stipple) {
1323         immUniform1f("dash_width", 6.0f);
1324         immUniform1f("dash_factor", 0.5f);
1325       }
1326       else {
1327         immUniform1f("dash_factor", 2.0f); /* Solid line */
1328       }
1329
1330       if (draw_outline) {
1331         immUniformThemeColor(TH_MARKER_OUTLINE);
1332       }
1333       else {
1334         plane_track_colors(is_active_track, color, selected_color);
1335         immUniformColor3fv(is_selected_track ? selected_color : color);
1336       }
1337
1338       /* Draw rectangle itself. */
1339       immBegin(GPU_PRIM_LINE_LOOP, 4);
1340       immVertex2fv(shdr_pos, plane_marker->corners[0]);
1341       immVertex2fv(shdr_pos, plane_marker->corners[1]);
1342       immVertex2fv(shdr_pos, plane_marker->corners[2]);
1343       immVertex2fv(shdr_pos, plane_marker->corners[3]);
1344       immEnd();
1345
1346       /* Draw axis. */
1347       if (!draw_outline) {
1348         float end_point[2];
1349
1350         immUniformColor3f(1.0f, 0.0f, 0.0f);
1351
1352         immBegin(GPU_PRIM_LINES, 2);
1353
1354         getArrowEndPoint(width,
1355                          height,
1356                          sc->zoom,
1357                          plane_marker->corners[0],
1358                          plane_marker->corners[1],
1359                          end_point);
1360         immVertex2fv(shdr_pos, plane_marker->corners[0]);
1361         immVertex2fv(shdr_pos, end_point);
1362
1363         immEnd();
1364
1365         immUniformColor3f(0.0f, 1.0f, 0.0f);
1366
1367         immBegin(GPU_PRIM_LINES, 2);
1368
1369         getArrowEndPoint(width,
1370                          height,
1371                          sc->zoom,
1372                          plane_marker->corners[0],
1373                          plane_marker->corners[3],
1374                          end_point);
1375         immVertex2fv(shdr_pos, plane_marker->corners[0]);
1376         immVertex2fv(shdr_pos, end_point);
1377
1378         immEnd();
1379       }
1380     }
1381
1382     /* Draw sliders. */
1383     if (is_selected_track) {
1384       immUniform1f("dash_factor", 2.0f); /* Solid line */
1385
1386       if (draw_outline) {
1387         immUniformThemeColor(TH_MARKER_OUTLINE);
1388       }
1389       else {
1390         immUniformColor3fv(selected_color);
1391       }
1392
1393       int i;
1394       for (i = 0; i < 4; i++) {
1395         draw_marker_slide_square(plane_marker->corners[i][0],
1396                                  plane_marker->corners[i][1],
1397                                  3.0f * px[0],
1398                                  3.0f * px[1],
1399                                  draw_outline,
1400                                  px,
1401                                  shdr_pos);
1402       }
1403     }
1404
1405     immUnbindProgram();
1406   }
1407 }
1408
1409 static void draw_plane_marker_outline(SpaceClip *sc,
1410                                       Scene *scene,
1411                                       MovieTrackingPlaneTrack *plane_track,
1412                                       MovieTrackingPlaneMarker *plane_marker,
1413                                       int width,
1414                                       int height)
1415 {
1416   draw_plane_marker_ex(sc, scene, plane_track, plane_marker, false, true, width, height);
1417 }
1418
1419 static void draw_plane_marker(SpaceClip *sc,
1420                               Scene *scene,
1421                               MovieTrackingPlaneTrack *plane_track,
1422                               MovieTrackingPlaneMarker *plane_marker,
1423                               bool is_active_track,
1424                               int width,
1425                               int height)
1426 {
1427   draw_plane_marker_ex(
1428       sc, scene, plane_track, plane_marker, is_active_track, false, width, height);
1429 }
1430
1431 static void draw_plane_track(SpaceClip *sc,
1432                              Scene *scene,
1433                              MovieTrackingPlaneTrack *plane_track,
1434                              int framenr,
1435                              bool is_active_track,
1436                              int width,
1437                              int height)
1438 {
1439   MovieTrackingPlaneMarker *plane_marker;
1440
1441   plane_marker = BKE_tracking_plane_marker_get(plane_track, framenr);
1442
1443   draw_plane_marker_outline(sc, scene, plane_track, plane_marker, width, height);
1444   draw_plane_marker(sc, scene, plane_track, plane_marker, is_active_track, width, height);
1445 }
1446
1447 /* Draw all kind of tracks. */
1448 static void draw_tracking_tracks(SpaceClip *sc,
1449                                  Scene *scene,
1450                                  ARegion *ar,
1451                                  MovieClip *clip,
1452                                  int width,
1453                                  int height,
1454                                  float zoomx,
1455                                  float zoomy)
1456 {
1457   float x, y;
1458   MovieTracking *tracking = &clip->tracking;
1459   ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
1460   ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
1461   MovieTrackingTrack *track, *act_track;
1462   MovieTrackingPlaneTrack *plane_track, *active_plane_track;
1463   MovieTrackingMarker *marker;
1464   int framenr = ED_space_clip_get_clip_frame_number(sc);
1465   int undistort = sc->user.render_flag & MCLIP_PROXY_RENDER_UNDISTORT;
1466   float *marker_pos = NULL, *fp, *active_pos = NULL, cur_pos[2];
1467
1468   /* ** find window pixel coordinates of origin ** */
1469
1470   /* UI_view2d_view_to_region_no_clip return integer values, this could
1471    * lead to 1px flickering when view is locked to selection during playback.
1472    * to avoid this flickering, calculate base point in the same way as it happens
1473    * in UI_view2d_view_to_region_no_clip, but do it in floats here */
1474
1475   UI_view2d_view_to_region_fl(&ar->v2d, 0.0f, 0.0f, &x, &y);
1476
1477   GPU_matrix_push();
1478   GPU_matrix_translate_2f(x, y);
1479
1480   GPU_matrix_push();
1481   GPU_matrix_scale_2f(zoomx, zoomy);
1482   GPU_matrix_mul(sc->stabmat);
1483   GPU_matrix_scale_2f(width, height);
1484
1485   act_track = BKE_tracking_track_get_active(tracking);
1486
1487   /* Draw plane tracks */
1488   active_plane_track = BKE_tracking_plane_track_get_active(tracking);
1489   for (plane_track = plane_tracks_base->first; plane_track; plane_track = plane_track->next) {
1490     if ((plane_track->flag & PLANE_TRACK_HIDDEN) == 0) {
1491       draw_plane_track(
1492           sc, scene, plane_track, framenr, plane_track == active_plane_track, width, height);
1493     }
1494   }
1495
1496   if (sc->user.render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
1497     int count = 0;
1498
1499     /* count */
1500     track = tracksbase->first;
1501     while (track) {
1502       if ((track->flag & TRACK_HIDDEN) == 0) {
1503         marker = BKE_tracking_marker_get(track, framenr);
1504
1505         if (MARKER_VISIBLE(sc, track, marker)) {
1506           count++;
1507         }
1508       }
1509
1510       track = track->next;
1511     }
1512
1513     /* undistort */
1514     if (count) {
1515       marker_pos = MEM_callocN(2 * sizeof(float) * count, "draw_tracking_tracks marker_pos");
1516
1517       track = tracksbase->first;
1518       fp = marker_pos;
1519       while (track) {
1520         if ((track->flag & TRACK_HIDDEN) == 0) {
1521           marker = BKE_tracking_marker_get(track, framenr);
1522
1523           if (MARKER_VISIBLE(sc, track, marker)) {
1524             ED_clip_point_undistorted_pos(sc, marker->pos, fp);
1525
1526             if (track == act_track) {
1527               active_pos = fp;
1528             }
1529
1530             fp += 2;
1531           }
1532         }
1533
1534         track = track->next;
1535       }
1536     }
1537   }
1538
1539   if (sc->flag & SC_SHOW_TRACK_PATH) {
1540     track = tracksbase->first;
1541     while (track) {
1542       if ((track->flag & TRACK_HIDDEN) == 0) {
1543         draw_track_path(sc, clip, track);
1544       }
1545
1546       track = track->next;
1547     }
1548   }
1549
1550   uint position = GPU_vertformat_attr_add(
1551       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1552
1553   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1554
1555   /* markers outline and non-selected areas */
1556   track = tracksbase->first;
1557   fp = marker_pos;
1558   while (track) {
1559     if ((track->flag & TRACK_HIDDEN) == 0) {
1560       marker = BKE_tracking_marker_get(track, framenr);
1561
1562       if (MARKER_VISIBLE(sc, track, marker)) {
1563         copy_v2_v2(cur_pos, fp ? fp : marker->pos);
1564
1565         draw_marker_outline(sc, track, marker, cur_pos, width, height, position);
1566         draw_marker_areas(sc, track, marker, cur_pos, width, height, 0, 0, position);
1567         draw_marker_slide_zones(sc, track, marker, cur_pos, 1, 0, 0, width, height, position);
1568         draw_marker_slide_zones(sc, track, marker, cur_pos, 0, 0, 0, width, height, position);
1569
1570         if (fp) {
1571           fp += 2;
1572         }
1573       }
1574     }
1575
1576     track = track->next;
1577   }
1578
1579   /* selected areas only, so selection wouldn't be overlapped by
1580    * non-selected areas */
1581   track = tracksbase->first;
1582   fp = marker_pos;
1583   while (track) {
1584     if ((track->flag & TRACK_HIDDEN) == 0) {
1585       int act = track == act_track;
1586       marker = BKE_tracking_marker_get(track, framenr);
1587
1588       if (MARKER_VISIBLE(sc, track, marker)) {
1589         if (!act) {
1590           copy_v2_v2(cur_pos, fp ? fp : marker->pos);
1591
1592           draw_marker_areas(sc, track, marker, cur_pos, width, height, 0, 1, position);
1593           draw_marker_slide_zones(sc, track, marker, cur_pos, 0, 1, 0, width, height, position);
1594         }
1595
1596         if (fp) {
1597           fp += 2;
1598         }
1599       }
1600     }
1601
1602     track = track->next;
1603   }
1604
1605   /* active marker would be displayed on top of everything else */
1606   if (act_track) {
1607     if ((act_track->flag & TRACK_HIDDEN) == 0) {
1608       marker = BKE_tracking_marker_get(act_track, framenr);
1609
1610       if (MARKER_VISIBLE(sc, act_track, marker)) {
1611         copy_v2_v2(cur_pos, active_pos ? active_pos : marker->pos);
1612
1613         draw_marker_areas(sc, act_track, marker, cur_pos, width, height, 1, 1, position);
1614         draw_marker_slide_zones(sc, act_track, marker, cur_pos, 0, 1, 1, width, height, position);
1615       }
1616     }
1617   }
1618
1619   if (sc->flag & SC_SHOW_BUNDLES) {
1620     MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
1621     float pos[4], vec[4], mat[4][4], aspy;
1622
1623     GPU_point_size(3.0f);
1624
1625     aspy = 1.0f / clip->tracking.camera.pixel_aspect;
1626     BKE_tracking_get_projection_matrix(tracking, object, framenr, width, height, mat);
1627
1628     track = tracksbase->first;
1629     while (track) {
1630       if ((track->flag & TRACK_HIDDEN) == 0 && track->flag & TRACK_HAS_BUNDLE) {
1631         marker = BKE_tracking_marker_get(track, framenr);
1632
1633         if (MARKER_VISIBLE(sc, track, marker)) {
1634           float npos[2];
1635           copy_v3_v3(vec, track->bundle_pos);
1636           vec[3] = 1;
1637
1638           mul_v4_m4v4(pos, mat, vec);
1639
1640           pos[0] = (pos[0] / (pos[3] * 2.0f) + 0.5f) * width;
1641           pos[1] = (pos[1] / (pos[3] * 2.0f) + 0.5f) * height * aspy;
1642
1643           BKE_tracking_distort_v2(tracking, pos, npos);
1644
1645           if (npos[0] >= 0.0f && npos[1] >= 0.0f && npos[0] <= width && npos[1] <= height * aspy) {
1646             vec[0] = (marker->pos[0] + track->offset[0]) * width;
1647             vec[1] = (marker->pos[1] + track->offset[1]) * height * aspy;
1648
1649             sub_v2_v2(vec, npos);
1650
1651             if (len_squared_v2(vec) < (3.0f * 3.0f)) {
1652               immUniformColor3f(0.0f, 1.0f, 0.0f);
1653             }
1654             else {
1655               immUniformColor3f(1.0f, 0.0f, 0.0f);
1656             }
1657
1658             immBegin(GPU_PRIM_POINTS, 1);
1659
1660             if (undistort) {
1661               immVertex2f(position, pos[0] / width, pos[1] / (height * aspy));
1662             }
1663             else {
1664               immVertex2f(position, npos[0] / width, npos[1] / (height * aspy));
1665             }
1666
1667             immEnd();
1668           }
1669         }
1670       }
1671
1672       track = track->next;
1673     }
1674   }
1675
1676   immUnbindProgram();
1677
1678   GPU_matrix_pop();
1679
1680   if (sc->flag & SC_SHOW_NAMES) {
1681     /* scaling should be cleared before drawing texts, otherwise font would also be scaled */
1682     track = tracksbase->first;
1683     fp = marker_pos;
1684     while (track) {
1685       if ((track->flag & TRACK_HIDDEN) == 0) {
1686         marker = BKE_tracking_marker_get(track, framenr);
1687
1688         if (MARKER_VISIBLE(sc, track, marker)) {
1689           int act = track == act_track;
1690
1691           copy_v2_v2(cur_pos, fp ? fp : marker->pos);
1692
1693           draw_marker_texts(sc, track, marker, cur_pos, act, width, height, zoomx, zoomy);
1694
1695           if (fp) {
1696             fp += 2;
1697           }
1698         }
1699       }
1700
1701       track = track->next;
1702     }
1703   }
1704
1705   GPU_matrix_pop();
1706
1707   if (marker_pos) {
1708     MEM_freeN(marker_pos);
1709   }
1710 }
1711
1712 static void draw_distortion(
1713     SpaceClip *sc, ARegion *ar, MovieClip *clip, int width, int height, float zoomx, float zoomy)
1714 {
1715   float x, y;
1716   const int n = 10;
1717   int i, j, a;
1718   float pos[2], tpos[2], grid[11][11][2];
1719   MovieTracking *tracking = &clip->tracking;
1720   bGPdata *gpd = NULL;
1721   float aspy = 1.0f / tracking->camera.pixel_aspect;
1722   float dx = (float)width / n, dy = (float)height / n * aspy;
1723   float offsx = 0.0f, offsy = 0.0f;
1724
1725   if (!tracking->camera.focal) {
1726     return;
1727   }
1728
1729   if ((sc->flag & SC_SHOW_GRID) == 0 && (sc->flag & SC_MANUAL_CALIBRATION) == 0) {
1730     return;
1731   }
1732
1733   UI_view2d_view_to_region_fl(&ar->v2d, 0.0f, 0.0f, &x, &y);
1734
1735   GPU_matrix_push();
1736   GPU_matrix_translate_2f(x, y);
1737   GPU_matrix_scale_2f(zoomx, zoomy);
1738   GPU_matrix_mul(sc->stabmat);
1739   GPU_matrix_scale_2f(width, height);
1740
1741   uint position = GPU_vertformat_attr_add(
1742       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1743
1744   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1745
1746   /* grid */
1747   if (sc->flag & SC_SHOW_GRID) {
1748     float val[4][2], idx[4][2];
1749     float min[2], max[2];
1750
1751     for (a = 0; a < 4; a++) {
1752       if (a < 2) {
1753         val[a][a % 2] = FLT_MAX;
1754       }
1755       else {
1756         val[a][a % 2] = -FLT_MAX;
1757       }
1758     }
1759
1760     zero_v2(pos);
1761     for (i = 0; i <= n; i++) {
1762       for (j = 0; j <= n; j++) {
1763         if (i == 0 || j == 0 || i == n || j == n) {
1764           BKE_tracking_distort_v2(tracking, pos, tpos);
1765
1766           for (a = 0; a < 4; a++) {
1767             int ok;
1768
1769             if (a < 2) {
1770               ok = tpos[a % 2] < val[a][a % 2];
1771             }
1772             else {
1773               ok = tpos[a % 2] > val[a][a % 2];
1774             }
1775
1776             if (ok) {
1777               copy_v2_v2(val[a], tpos);
1778               idx[a][0] = j;
1779               idx[a][1] = i;
1780             }
1781           }
1782         }
1783
1784         pos[0] += dx;
1785       }
1786
1787       pos[0] = 0.0f;
1788       pos[1] += dy;
1789     }
1790
1791     INIT_MINMAX2(min, max);
1792
1793     for (a = 0; a < 4; a++) {
1794       pos[0] = idx[a][0] * dx;
1795       pos[1] = idx[a][1] * dy;
1796
1797       BKE_tracking_undistort_v2(tracking, pos, tpos);
1798
1799       minmax_v2v2_v2(min, max, tpos);
1800     }
1801
1802     copy_v2_v2(pos, min);
1803     dx = (max[0] - min[0]) / n;
1804     dy = (max[1] - min[1]) / n;
1805
1806     for (i = 0; i <= n; i++) {
1807       for (j = 0; j <= n; j++) {
1808         BKE_tracking_distort_v2(tracking, pos, grid[i][j]);
1809
1810         grid[i][j][0] /= width;
1811         grid[i][j][1] /= height * aspy;
1812
1813         pos[0] += dx;
1814       }
1815
1816       pos[0] = min[0];
1817       pos[1] += dy;
1818     }
1819
1820     immUniformColor3f(1.0f, 0.0f, 0.0f);
1821
1822     for (i = 0; i <= n; i++) {
1823       immBegin(GPU_PRIM_LINE_STRIP, n + 1);
1824
1825       for (j = 0; j <= n; j++) {
1826         immVertex2fv(position, grid[i][j]);
1827       }
1828
1829       immEnd();
1830     }
1831
1832     for (j = 0; j <= n; j++) {
1833       immBegin(GPU_PRIM_LINE_STRIP, n + 1);
1834
1835       for (i = 0; i <= n; i++) {
1836         immVertex2fv(position, grid[i][j]);
1837       }
1838
1839       immEnd();
1840     }
1841   }
1842
1843   if (sc->gpencil_src != SC_GPENCIL_SRC_TRACK) {
1844     gpd = clip->gpd;
1845   }
1846
1847   if (sc->flag & SC_MANUAL_CALIBRATION && gpd) {
1848     bGPDlayer *layer = gpd->layers.first;
1849
1850     while (layer) {
1851       bGPDframe *frame = layer->frames.first;
1852
1853       if (layer->flag & GP_LAYER_HIDE) {
1854         layer = layer->next;
1855         continue;
1856       }
1857
1858       immUniformColor4fv(layer->color);
1859
1860       GPU_line_width(layer->thickness);
1861       GPU_point_size((float)(layer->thickness + 2));
1862
1863       while (frame) {
1864         bGPDstroke *stroke = frame->strokes.first;
1865
1866         while (stroke) {
1867           if (stroke->flag & GP_STROKE_2DSPACE) {
1868             if (stroke->totpoints > 1) {
1869               for (i = 0; i < stroke->totpoints - 1; i++) {
1870                 float npos[2], dpos[2], len;
1871                 int steps;
1872
1873                 pos[0] = (stroke->points[i].x + offsx) * width;
1874                 pos[1] = (stroke->points[i].y + offsy) * height * aspy;
1875
1876                 npos[0] = (stroke->points[i + 1].x + offsx) * width;
1877                 npos[1] = (stroke->points[i + 1].y + offsy) * height * aspy;
1878
1879                 len = len_v2v2(pos, npos);
1880                 steps = ceil(len / 5.0f);
1881
1882                 /* we want to distort only long straight lines */
1883                 if (stroke->totpoints == 2) {
1884                   BKE_tracking_undistort_v2(tracking, pos, pos);
1885                   BKE_tracking_undistort_v2(tracking, npos, npos);
1886                 }
1887
1888                 sub_v2_v2v2(dpos, npos, pos);
1889                 mul_v2_fl(dpos, 1.0f / steps);
1890
1891                 immBegin(GPU_PRIM_LINE_STRIP, steps + 1);
1892
1893                 for (j = 0; j <= steps; j++) {
1894                   BKE_tracking_distort_v2(tracking, pos, tpos);
1895                   immVertex2f(position, tpos[0] / width, tpos[1] / (height * aspy));
1896
1897                   add_v2_v2(pos, dpos);
1898                 }
1899
1900                 immEnd();
1901               }
1902             }
1903             else if (stroke->totpoints == 1) {
1904               immBegin(GPU_PRIM_POINTS, 1);
1905               immVertex2f(position, stroke->points[0].x + offsx, stroke->points[0].y + offsy);
1906               immEnd();
1907             }
1908           }
1909
1910           stroke = stroke->next;
1911         }
1912
1913         frame = frame->next;
1914       }
1915
1916       layer = layer->next;
1917     }
1918   }
1919
1920   immUnbindProgram();
1921
1922   GPU_matrix_pop();
1923 }
1924
1925 void clip_draw_main(const bContext *C, SpaceClip *sc, ARegion *ar)
1926 {
1927   MovieClip *clip = ED_space_clip_get_clip(sc);
1928   Scene *scene = CTX_data_scene(C);
1929   ImBuf *ibuf = NULL;
1930   int width, height;
1931   float zoomx, zoomy;
1932
1933   ED_space_clip_get_size(sc, &width, &height);
1934   ED_space_clip_get_zoom(sc, ar, &zoomx, &zoomy);
1935
1936   /* if no clip, nothing to do */
1937   if (!clip) {
1938     ED_region_grid_draw(ar, zoomx, zoomy);
1939     return;
1940   }
1941
1942   if (sc->flag & SC_SHOW_STABLE) {
1943     float translation[2];
1944     float aspect = clip->tracking.camera.pixel_aspect;
1945     float smat[4][4], ismat[4][4];
1946
1947     if ((sc->flag & SC_MUTE_FOOTAGE) == 0) {
1948       ibuf = ED_space_clip_get_stable_buffer(sc, sc->loc, &sc->scale, &sc->angle);
1949     }
1950
1951     if (ibuf != NULL && width != ibuf->x) {
1952       mul_v2_v2fl(translation, sc->loc, (float)width / ibuf->x);
1953     }
1954     else {
1955       copy_v2_v2(translation, sc->loc);
1956     }
1957
1958     BKE_tracking_stabilization_data_to_mat4(
1959         width, height, aspect, translation, sc->scale, sc->angle, sc->stabmat);
1960
1961     unit_m4(smat);
1962     smat[0][0] = 1.0f / width;
1963     smat[1][1] = 1.0f / height;
1964     invert_m4_m4(ismat, smat);
1965
1966     mul_m4_series(sc->unistabmat, smat, sc->stabmat, ismat);
1967   }
1968   else if ((sc->flag & SC_MUTE_FOOTAGE) == 0) {
1969     ibuf = ED_space_clip_get_buffer(sc);
1970
1971     zero_v2(sc->loc);
1972     sc->scale = 1.0f;
1973     unit_m4(sc->stabmat);
1974     unit_m4(sc->unistabmat);
1975   }
1976
1977   if (ibuf) {
1978     draw_movieclip_buffer(C, sc, ar, ibuf, width, height, zoomx, zoomy);
1979     IMB_freeImBuf(ibuf);
1980   }
1981   else if (sc->flag & SC_MUTE_FOOTAGE) {
1982     draw_movieclip_muted(ar, width, height, zoomx, zoomy);
1983   }
1984   else {
1985     ED_region_grid_draw(ar, zoomx, zoomy);
1986   }
1987
1988   if (width && height) {
1989     draw_stabilization_border(sc, ar, width, height, zoomx, zoomy);
1990     draw_tracking_tracks(sc, scene, ar, clip, width, height, zoomx, zoomy);
1991     draw_distortion(sc, ar, clip, width, height, zoomx, zoomy);
1992   }
1993 }
1994
1995 void clip_draw_cache_and_notes(const bContext *C, SpaceClip *sc, ARegion *ar)
1996 {
1997   Scene *scene = CTX_data_scene(C);
1998   MovieClip *clip = ED_space_clip_get_clip(sc);
1999   if (clip) {
2000     draw_movieclip_cache(sc, ar, clip, scene);
2001     draw_movieclip_notes(sc, ar);
2002   }
2003 }
2004
2005 /* draw grease pencil */
2006 void clip_draw_grease_pencil(bContext *C, int onlyv2d)
2007 {
2008   SpaceClip *sc = CTX_wm_space_clip(C);
2009   MovieClip *clip = ED_space_clip_get_clip(sc);
2010
2011   if (!clip) {
2012     return;
2013   }
2014
2015   if (onlyv2d) {
2016     bool is_track_source = sc->gpencil_src == SC_GPENCIL_SRC_TRACK;
2017     /* if manual calibration is used then grease pencil data
2018      * associated with the clip is already drawn in draw_distortion
2019      */
2020     if ((sc->flag & SC_MANUAL_CALIBRATION) == 0 || is_track_source) {
2021       GPU_matrix_push();
2022       GPU_matrix_mul(sc->unistabmat);
2023
2024       if (is_track_source) {
2025         MovieTrackingTrack *track = BKE_tracking_track_get_active(&sc->clip->tracking);
2026
2027         if (track) {
2028           int framenr = ED_space_clip_get_clip_frame_number(sc);
2029           MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
2030
2031           GPU_matrix_translate_2fv(marker->pos);
2032         }
2033       }
2034
2035       ED_annotation_draw_2dimage(C);
2036
2037       GPU_matrix_pop();
2038     }
2039   }
2040   else {
2041     ED_annotation_draw_view2d(C, 0);
2042   }
2043 }