source/blender/editors/space_clip/clip_utils.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2011 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  *
  22  * Contributor(s): Blender Foundation,
  23  *                 Sergey Sharybin
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 /** \file blender/editors/space_clip/clip_utils.c
  29  *  \ingroup spclip
  30  */
  31
  32 #include "DNA_scene_types.h"
  33
  34 #include "MEM_guardedalloc.h"
  35
  36 #include "BLI_utildefines.h"
  37 #include "BLI_listbase.h"
  38 #include "BLI_string.h"
  39
  40 #include "BKE_animsys.h"
  41 #include "BKE_context.h"
  42 #include "BKE_movieclip.h"
  43 #include "BKE_tracking.h"
  44 #include "BKE_depsgraph.h"
  45
  46 #include "BIF_gl.h"
  47 #include "BIF_glutil.h"
  48
  49 #include "WM_api.h"
  50 #include "WM_types.h"
  51
  52 #include "ED_screen.h"
  53 #include "ED_clip.h"
  54
  55
  56 #include "UI_interface.h"
  57 #include "UI_resources.h"
  58 #include "UI_view2d.h"
  59
  60 #include "clip_intern.h"    // own include
  61
  62 void clip_graph_tracking_values_iterate_track(
  63         SpaceClip *sc, MovieTrackingTrack *track, void *userdata,
  64         void (*func)(void *userdata, MovieTrackingTrack *track, MovieTrackingMarker *marker, int coord,
  65                      int scene_framenr, float val),
  66         void (*segment_start)(void *userdata, MovieTrackingTrack *track, int coord),
  67         void (*segment_end)(void *userdata, int coord))
  68 {
  69         MovieClip *clip = ED_space_clip_get_clip(sc);
  70         int width, height, coord;
  71
  72         BKE_movieclip_get_size(clip, &sc->user, &width, &height);
  73
  74         for (coord = 0; coord < 2; coord++) {
  75                 int i, prevfra = 0;
  76                 bool open = false;
  77                 float prevval = 0.0f;
  78
  79                 for (i = 0; i < track->markersnr; i++) {
  80                         MovieTrackingMarker *marker = &track->markers[i];
  81                         float val;
  82
  83                         if (marker->flag & MARKER_DISABLED) {
  84                                 if (open) {
  85                                         if (segment_end)
  86                                                 segment_end(userdata, coord);
  87
  88                                         open = false;
  89                                 }
  90
  91                                 continue;
  92                         }
  93
  94                         if (!open) {
  95                                 if (segment_start)
  96                                         segment_start(userdata, track, coord);
  97
  98                                 open = true;
  99                                 prevval = marker->pos[coord];
 100                         }
 101
 102                         /* value is a pixels per frame speed */
 103                         val = (marker->pos[coord] - prevval) * ((coord == 0) ? (width) : (height));
 104                         val /= marker->framenr - prevfra;
 105
 106                         if (func) {
 107                                 int scene_framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, marker->framenr);
 108
 109                                 func(userdata, track, marker, coord, scene_framenr, val);
 110                         }
 111
 112                         prevval = marker->pos[coord];
 113                         prevfra = marker->framenr;
 114                 }
 115
 116                 if (open) {
 117                         if (segment_end)
 118                                 segment_end(userdata, coord);
 119                 }
 120         }
 121 }
 122
 123 void clip_graph_tracking_values_iterate(
 124         SpaceClip *sc, bool selected_only, bool include_hidden, void *userdata,
 125         void (*func)(void *userdata, MovieTrackingTrack *track, MovieTrackingMarker *marker,
 126                      int coord, int scene_framenr, float val),
 127         void (*segment_start)(void *userdata, MovieTrackingTrack *track, int coord),
 128         void (*segment_end)(void *userdata, int coord))
 129 {
 130         MovieClip *clip = ED_space_clip_get_clip(sc);
 131         MovieTracking *tracking = &clip->tracking;
 132         ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 133         MovieTrackingTrack *track;
 134
 135         for (track = tracksbase->first; track; track = track->next) {
 136                 if (!include_hidden && (track->flag & TRACK_HIDDEN) != 0)
 137                         continue;
 138
 139                 if (selected_only && !TRACK_SELECTED(track))
 140                         continue;
 141
 142                 clip_graph_tracking_values_iterate_track(sc, track, userdata, func, segment_start, segment_end);
 143         }
 144 }
 145
 146 void clip_graph_tracking_iterate(SpaceClip *sc, bool selected_only, bool include_hidden, void *userdata,
 147                                  void (*func)(void *userdata, MovieTrackingMarker *marker))
 148 {
 149         MovieClip *clip = ED_space_clip_get_clip(sc);
 150         MovieTracking *tracking = &clip->tracking;
 151         ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 152         MovieTrackingTrack *track;
 153
 154         for (track = tracksbase->first; track; track = track->next) {
 155                 int i;
 156
 157                 if (!include_hidden && (track->flag & TRACK_HIDDEN) != 0)
 158                         continue;
 159
 160                 if (selected_only && !TRACK_SELECTED(track))
 161                         continue;
 162
 163                 for (i = 0; i < track->markersnr; i++) {
 164                         MovieTrackingMarker *marker = &track->markers[i];
 165
 166                         if (marker->flag & MARKER_DISABLED)
 167                                 continue;
 168
 169                         if (func)
 170                                 func(userdata, marker);
 171                 }
 172         }
 173 }
 174
 175 void clip_delete_track(bContext *C, MovieClip *clip, MovieTrackingTrack *track)
 176 {
 177         MovieTracking *tracking = &clip->tracking;
 178         MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
 179         ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 180         bool has_bundle = false;
 181         char track_name_escaped[MAX_NAME], prefix[MAX_NAME * 2];
 182         const bool used_for_stabilization = (track->flag & (TRACK_USE_2D_STAB | TRACK_USE_2D_STAB_ROT));
 183
 184         if (track == act_track)
 185                 tracking->act_track = NULL;
 186
 187         /* handle reconstruction display in 3d viewport */
 188         if (track->flag & TRACK_HAS_BUNDLE)
 189                 has_bundle = true;
 190
 191         /* Make sure no plane will use freed track */
 192         BKE_tracking_plane_tracks_remove_point_track(tracking, track);
 193
 194         /* Delete f-curves associated with the track (such as weight, i.e.) */
 195         BLI_strescape(track_name_escaped, track->name, sizeof(track_name_escaped));
 196         BLI_snprintf(prefix, sizeof(prefix), "tracks[\"%s\"]", track_name_escaped);
 197         BKE_animdata_fix_paths_remove(&clip->id, prefix);
 198
 199         BKE_tracking_track_free(track);
 200         BLI_freelinkN(tracksbase, track);
 201
 202         WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
 203
 204         if (used_for_stabilization) {
 205                 WM_event_add_notifier(C, NC_MOVIECLIP | ND_DISPLAY, clip);
 206         }
 207
 208         DAG_id_tag_update(&clip->id, 0);
 209
 210         if (has_bundle)
 211                 WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 212 }
 213
 214 void clip_delete_marker(bContext *C, MovieClip *clip, MovieTrackingTrack *track,
 215                         MovieTrackingMarker *marker)
 216 {
 217         if (track->markersnr == 1) {
 218                 clip_delete_track(C, clip, track);
 219         }
 220         else {
 221                 BKE_tracking_marker_delete(track, marker->framenr);
 222
 223                 WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
 224         }
 225 }
 226
 227 void clip_view_center_to_point(SpaceClip *sc, float x, float y)
 228 {
 229         int width, height;
 230         float aspx, aspy;
 231
 232         ED_space_clip_get_size(sc, &width, &height);
 233         ED_space_clip_get_aspect(sc, &aspx, &aspy);
 234
 235         sc->xof = (x - 0.5f) * width * aspx;
 236         sc->yof = (y - 0.5f) * height * aspy;
 237 }
 238
 239 void clip_draw_cfra(SpaceClip *sc, ARegion *ar, Scene *scene)
 240 {
 241         View2D *v2d = &ar->v2d;
 242         float xscale, yscale;
 243
 244         /* Draw a light green line to indicate current frame */
 245         UI_ThemeColor(TH_CFRAME);
 246
 247         float x = (float)(sc->user.framenr * scene->r.framelen);
 248
 249         glLineWidth(2.0);
 250
 251         glBegin(GL_LINES);
 252         glVertex2f(x, v2d->cur.ymin);
 253         glVertex2f(x, v2d->cur.ymax);
 254         glEnd();
 255
 256         UI_view2d_view_orthoSpecial(ar, v2d, 1);
 257
 258         /* because the frame number text is subject to the same scaling as the contents of the view */
 259         UI_view2d_scale_get(v2d, &xscale, &yscale);
 260         glScalef(1.0f / xscale, 1.0f, 1.0f);
 261
 262         ED_region_cache_draw_curfra_label(sc->user.framenr, (float)sc->user.framenr * xscale, 18);
 263
 264         /* restore view transform */
 265         glScalef(xscale, 1.0, 1.0);
 266 }
 267
 268 void clip_draw_sfra_efra(View2D *v2d, Scene *scene)
 269 {
 270         UI_view2d_view_ortho(v2d);
 271
 272         /* currently clip editor supposes that editing clip length is equal to scene frame range */
 273         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 274         glEnable(GL_BLEND);
 275         glColor4f(0.0f, 0.0f, 0.0f, 0.4f);
 276
 277         glRectf(v2d->cur.xmin, v2d->cur.ymin, (float)SFRA, v2d->cur.ymax);
 278         glRectf((float)EFRA, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
 279         glDisable(GL_BLEND);
 280
 281         UI_ThemeColorShade(TH_BACK, -60);
 282
 283         /* thin lines where the actual frames are */
 284         fdrawline((float)SFRA, v2d->cur.ymin, (float)SFRA, v2d->cur.ymax);
 285         fdrawline((float)EFRA, v2d->cur.ymin, (float)EFRA, v2d->cur.ymax);
 286 }