diff --git a/source/blender/blenkernel/BKE_tracking.h b/source/blender/blenkernel/BKE_tracking.h index ff12cf4d2bf..11356aa0384 100644 --- a/source/blender/blenkernel/BKE_tracking.h +++ b/source/blender/blenkernel/BKE_tracking.h @@ -95,7 +95,7 @@ void BKE_tracking_get_camera_object_matrix(struct Object *camera_object, float m * \note frame number should be in clip space, not scene space. */ void BKE_tracking_get_projection_matrix(struct MovieTracking *tracking, - struct MovieTrackingObject *object, + struct MovieTrackingObject *tracking_object, int framenr, int winx, int winy, @@ -113,7 +113,7 @@ void BKE_tracking_clipboard_free(void); * Copy selected tracks from specified object to the clipboard. */ void BKE_tracking_clipboard_copy_tracks(struct MovieTracking *tracking, - struct MovieTrackingObject *object); + struct MovieTrackingObject *tracking_object); /** * Check whether there are any tracks in the clipboard. */ @@ -124,7 +124,7 @@ bool BKE_tracking_clipboard_has_tracks(void); * Names of new tracks in object are guaranteed to be unique here. */ void BKE_tracking_clipboard_paste_tracks(struct MovieTracking *tracking, - struct MovieTrackingObject *object); + struct MovieTrackingObject *tracking_object); /* **** Track **** */ @@ -248,9 +248,8 @@ void BKE_tracking_tracks_average(struct MovieTrackingTrack *dst_track, /*const*/ struct MovieTrackingTrack **src_tracks, int num_src_tracks); -struct MovieTrackingTrack *BKE_tracking_track_get_named(struct MovieTracking *tracking, - struct MovieTrackingObject *object, - const char *name); +struct MovieTrackingTrack *BKE_tracking_track_get_named( + struct MovieTracking *tracking, struct MovieTrackingObject *tracking_object, const char *name); struct MovieTrackingTrack *BKE_tracking_track_get_indexed(struct MovieTracking *tracking, int tracknr, struct ListBase **r_tracksbase); @@ -382,7 +381,7 @@ bool BKE_tracking_plane_track_has_enabled_marker_at_frame( struct MovieTrackingPlaneTrack *plane_track, int framenr); struct MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_named( - struct MovieTracking *tracking, struct MovieTrackingObject *object, const char *name); + struct MovieTracking *tracking, struct MovieTrackingObject *tracking_object, const char *name); struct MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_active( struct MovieTracking *tracking); @@ -440,10 +439,10 @@ void BKE_tracking_plane_marker_get_subframe_corners(struct MovieTrackingPlaneTra struct MovieTrackingObject *BKE_tracking_object_add(struct MovieTracking *tracking, const char *name); bool BKE_tracking_object_delete(struct MovieTracking *tracking, - struct MovieTrackingObject *object); + struct MovieTrackingObject *tracking_object); void BKE_tracking_object_unique_name(struct MovieTracking *tracking, - struct MovieTrackingObject *object); + struct MovieTrackingObject *tracking_object); struct MovieTrackingObject *BKE_tracking_object_get_named(struct MovieTracking *tracking, const char *name); @@ -467,9 +466,9 @@ void BKE_tracking_camera_to_blender(struct MovieTracking *tracking, int height); struct MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed( - struct MovieTracking *tracking, struct MovieTrackingObject *object, int framenr); + struct MovieTracking *tracking, struct MovieTrackingObject *tracking_object, int framenr); void BKE_tracking_camera_get_reconstructed_interpolate(struct MovieTracking *tracking, - struct MovieTrackingObject *object, + struct MovieTrackingObject *tracking_object, float framenr, float mat[4][4]); @@ -619,7 +618,7 @@ void BKE_tracking_homography_between_two_quads(/*const*/ float reference_corners * Perform early check on whether everything is fine to start reconstruction. */ bool BKE_tracking_reconstruction_check(struct MovieTracking *tracking, - struct MovieTrackingObject *object, + struct MovieTrackingObject *tracking_object, char *error_msg, int error_size); @@ -630,7 +629,7 @@ bool BKE_tracking_reconstruction_check(struct MovieTracking *tracking, */ struct MovieReconstructContext *BKE_tracking_reconstruction_context_new( struct MovieClip *clip, - struct MovieTrackingObject *object, + struct MovieTrackingObject *tracking_object, int keyframe1, int keyframe2, int width, diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c index bcc4ad0cb55..986f432b2fe 100644 --- a/source/blender/blenkernel/intern/constraint.c +++ b/source/blender/blenkernel/intern/constraint.c @@ -5232,11 +5232,11 @@ static void camerasolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase if (clip) { float mat[4][4], obmat[4][4]; MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object = BKE_tracking_object_get_camera(tracking); - float ctime = DEG_get_ctime(depsgraph); - float framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_camera(tracking); + const float ctime = DEG_get_ctime(depsgraph); + const float framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime); - BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat); + BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, mat); copy_m4_m4(obmat, cob->matrix); @@ -5294,10 +5294,8 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase } MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object; - - object = BKE_tracking_object_get_named(tracking, data->object); - if (!object) { + MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, data->object); + if (!tracking_object) { return; } @@ -5305,7 +5303,7 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase float ctime = DEG_get_ctime(depsgraph); float framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime); - BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat); + BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, mat); invert_m4_m4(imat, mat); mul_m4_m4m4(parmat, camob->object_to_world, imat); diff --git a/source/blender/blenkernel/intern/tracking.c b/source/blender/blenkernel/intern/tracking.c index 5036218b1a9..32e31cdfc0f 100644 --- a/source/blender/blenkernel/intern/tracking.c +++ b/source/blender/blenkernel/intern/tracking.c @@ -101,11 +101,11 @@ static void tracking_reconstruction_free(MovieTrackingReconstruction *reconstruc * * All the pointers inside structure becomes invalid after this call. */ -static void tracking_object_free(MovieTrackingObject *object) +static void tracking_object_free(MovieTrackingObject *tracking_object) { - tracking_tracks_free(&object->tracks); - tracking_plane_tracks_free(&object->plane_tracks); - tracking_reconstruction_free(&object->reconstruction); + tracking_tracks_free(&tracking_object->tracks); + tracking_plane_tracks_free(&tracking_object->plane_tracks); + tracking_reconstruction_free(&tracking_object->reconstruction); } /* Free list of tracking objects, list's head and tail is set to NULL. */ @@ -252,43 +252,45 @@ static void tracking_stabilization_copy(MovieTrackingStabilization *stabilizatio } /* Copy tracking object. */ -static void tracking_object_copy(MovieTrackingObject *object_dst, - const MovieTrackingObject *object_src, +static void tracking_object_copy(MovieTrackingObject *tracking_object_dst, + const MovieTrackingObject *tracking_object_src, const int flag) { TrackingCopyContext ctx = tracking_copy_context_new(); - *object_dst = *object_src; - tracking_tracks_copy(&ctx, &object_dst->tracks, &object_src->tracks, flag); - tracking_plane_tracks_copy(&ctx, &object_dst->plane_tracks, &object_src->plane_tracks, flag); - tracking_reconstruction_copy( - &ctx, &object_dst->reconstruction, &object_src->reconstruction, flag); + *tracking_object_dst = *tracking_object_src; - if (object_src->active_track) { - object_dst->active_track = BLI_ghash_lookup(ctx.old_to_new_track_map, - object_src->active_track); - BLI_assert(object_dst->active_track != NULL); + tracking_tracks_copy(&ctx, &tracking_object_dst->tracks, &tracking_object_src->tracks, flag); + tracking_plane_tracks_copy( + &ctx, &tracking_object_dst->plane_tracks, &tracking_object_src->plane_tracks, flag); + tracking_reconstruction_copy( + &ctx, &tracking_object_dst->reconstruction, &tracking_object_src->reconstruction, flag); + + if (tracking_object_src->active_track) { + tracking_object_dst->active_track = BLI_ghash_lookup(ctx.old_to_new_track_map, + tracking_object_src->active_track); + BLI_assert(tracking_object_dst->active_track != NULL); } - if (object_src->active_plane_track) { - object_dst->active_plane_track = BLI_ghash_lookup(ctx.old_to_new_track_map, - object_src->active_plane_track); - BLI_assert(object_dst->active_plane_track != NULL); + if (tracking_object_src->active_plane_track) { + tracking_object_dst->active_plane_track = BLI_ghash_lookup( + ctx.old_to_new_track_map, tracking_object_src->active_plane_track); + BLI_assert(tracking_object_dst->active_plane_track != NULL); } tracking_copy_context_delete(&ctx); } /* Copy list of tracking objects. */ -static void tracking_objects_copy(ListBase *objects_dst, - const ListBase *objects_src, +static void tracking_objects_copy(ListBase *tracking_objects_dst, + const ListBase *tracking_objects_src, const int flag) { - BLI_listbase_clear(objects_dst); + BLI_listbase_clear(tracking_objects_dst); - LISTBASE_FOREACH (MovieTrackingObject *, object_src, objects_src) { - MovieTrackingObject *object_dst = MEM_mallocN(sizeof(*object_dst), __func__); - tracking_object_copy(object_dst, object_src, flag); - BLI_addtail(objects_dst, object_dst); + LISTBASE_FOREACH (MovieTrackingObject *, tracking_object_src, tracking_objects_src) { + MovieTrackingObject *tracking_object_dst = MEM_mallocN(sizeof(*tracking_object_dst), __func__); + tracking_object_copy(tracking_object_dst, tracking_object_src, flag); + BLI_addtail(tracking_objects_dst, tracking_object_dst); } } @@ -355,24 +357,24 @@ void BKE_tracking_settings_init(MovieTracking *tracking) ListBase *BKE_tracking_get_active_tracks(MovieTracking *tracking) { - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); - BLI_assert(object != NULL); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); + BLI_assert(tracking_object != NULL); - return &object->tracks; + return &tracking_object->tracks; } ListBase *BKE_tracking_get_active_plane_tracks(MovieTracking *tracking) { - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); - BLI_assert(object != NULL); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); + BLI_assert(tracking_object != NULL); - return &object->plane_tracks; + return &tracking_object->plane_tracks; } MovieTrackingReconstruction *BKE_tracking_get_active_reconstruction(MovieTracking *tracking) { - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); - return &object->reconstruction; + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); + return &tracking_object->reconstruction; } void BKE_tracking_get_camera_object_matrix(Object *camera_object, float mat[4][4]) @@ -392,7 +394,7 @@ void BKE_tracking_get_camera_object_matrix(Object *camera_object, float mat[4][4 } void BKE_tracking_get_projection_matrix(MovieTracking *tracking, - MovieTrackingObject *object, + MovieTrackingObject *tracking_object, int framenr, int winx, int winy, @@ -431,7 +433,7 @@ void BKE_tracking_get_projection_matrix(MovieTracking *tracking, perspective_m4(winmat, left, right, bottom, top, clipsta, clipend); - camera = BKE_tracking_camera_get_reconstructed(tracking, object, framenr); + camera = BKE_tracking_camera_get_reconstructed(tracking, tracking_object, framenr); if (camera) { float imat[4][4]; @@ -465,13 +467,13 @@ void BKE_tracking_clipboard_free(void) } void BKE_tracking_clipboard_copy_tracks(MovieTracking *UNUSED(tracking), - MovieTrackingObject *object) + MovieTrackingObject *tracking_object) { /* First drop all tracks from current clipboard. */ BKE_tracking_clipboard_free(); /* Then copy all selected visible tracks to it. */ - LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { if (TRACK_SELECTED(track) && (track->flag & TRACK_HIDDEN) == 0) { MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track); @@ -486,18 +488,18 @@ bool BKE_tracking_clipboard_has_tracks(void) } void BKE_tracking_clipboard_paste_tracks(MovieTracking *UNUSED(tracking), - MovieTrackingObject *object) + MovieTrackingObject *tracking_object) { LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_clipboard.tracks) { MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track); /* TODO(sergey): Preserve active track from before the copy. */ if (track->prev == NULL) { - object->active_track = new_track; + tracking_object->active_track = new_track; } - BLI_addtail(&object->tracks, new_track); - BKE_tracking_track_unique_name(&object->tracks, new_track); + BLI_addtail(&tracking_object->tracks, new_track); + BKE_tracking_track_unique_name(&tracking_object->tracks, new_track); } } @@ -1033,10 +1035,10 @@ void BKE_tracking_tracks_average(MovieTrackingTrack *dst_track, } MovieTrackingTrack *BKE_tracking_track_get_named(MovieTracking *UNUSED(tracking), - MovieTrackingObject *object, + MovieTrackingObject *tracking_object, const char *name) { - LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { if (STREQ(track->name, name)) { return track; } @@ -1679,10 +1681,10 @@ void BKE_tracking_plane_track_free(MovieTrackingPlaneTrack *plane_track) } MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_named(MovieTracking *UNUSED(tracking), - MovieTrackingObject *object, + MovieTrackingObject *tracking_object, const char *name) { - LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &object->plane_tracks) { + LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &tracking_object->plane_tracks) { if (STREQ(plane_track->name, name)) { return plane_track; } @@ -1971,48 +1973,49 @@ void BKE_tracking_plane_marker_get_subframe_corners(MovieTrackingPlaneTrack *pla MovieTrackingObject *BKE_tracking_object_add(MovieTracking *tracking, const char *name) { - MovieTrackingObject *object = MEM_callocN(sizeof(MovieTrackingObject), "tracking object"); + MovieTrackingObject *tracking_object = MEM_callocN(sizeof(MovieTrackingObject), + "tracking object"); if (tracking->tot_object == 0) { /* first object is always camera */ - BLI_strncpy(object->name, "Camera", sizeof(object->name)); + BLI_strncpy(tracking_object->name, "Camera", sizeof(tracking_object->name)); - object->flag |= TRACKING_OBJECT_CAMERA; + tracking_object->flag |= TRACKING_OBJECT_CAMERA; } else { - BLI_strncpy(object->name, name, sizeof(object->name)); + BLI_strncpy(tracking_object->name, name, sizeof(tracking_object->name)); } - BLI_addtail(&tracking->objects, object); + BLI_addtail(&tracking->objects, tracking_object); tracking->tot_object++; tracking->objectnr = BLI_listbase_count(&tracking->objects) - 1; - object->scale = 1.0f; - object->keyframe1 = 1; - object->keyframe2 = 30; + tracking_object->scale = 1.0f; + tracking_object->keyframe1 = 1; + tracking_object->keyframe2 = 30; - BKE_tracking_object_unique_name(tracking, object); + BKE_tracking_object_unique_name(tracking, tracking_object); BKE_tracking_dopesheet_tag_update(tracking); - return object; + return tracking_object; } -bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *object) +bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *tracking_object) { - int index = BLI_findindex(&tracking->objects, object); + const int index = BLI_findindex(&tracking->objects, tracking_object); if (index == -1) { return false; } - if (object->flag & TRACKING_OBJECT_CAMERA) { + if (tracking_object->flag & TRACKING_OBJECT_CAMERA) { /* object used for camera solving can't be deleted */ return false; } - tracking_object_free(object); - BLI_freelinkN(&tracking->objects, object); + tracking_object_free(tracking_object); + BLI_freelinkN(&tracking->objects, tracking_object); tracking->tot_object--; @@ -2028,26 +2031,22 @@ bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *ob return true; } -void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *object) +void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *tracking_object) { BLI_uniquename(&tracking->objects, - object, + tracking_object, DATA_("Object"), '.', offsetof(MovieTrackingObject, name), - sizeof(object->name)); + sizeof(tracking_object->name)); } MovieTrackingObject *BKE_tracking_object_get_named(MovieTracking *tracking, const char *name) { - MovieTrackingObject *object = tracking->objects.first; - - while (object) { - if (STREQ(object->name, name)) { - return object; + LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) { + if (STREQ(tracking_object->name, name)) { + return tracking_object; } - - object = object->next; } return NULL; @@ -2060,14 +2059,10 @@ MovieTrackingObject *BKE_tracking_object_get_active(const MovieTracking *trackin MovieTrackingObject *BKE_tracking_object_get_camera(const MovieTracking *tracking) { - MovieTrackingObject *object = tracking->objects.first; - - while (object) { - if (object->flag & TRACKING_OBJECT_CAMERA) { - return object; + LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) { + if (tracking_object->flag & TRACKING_OBJECT_CAMERA) { + return tracking_object; } - - object = object->next; } return NULL; @@ -2147,12 +2142,13 @@ static int reconstructed_camera_index_get(MovieTrackingReconstruction *reconstru return -1; } -static void reconstructed_camera_scale_set(MovieTrackingObject *object, float mat[4][4]) +static void reconstructed_camera_scale_set(const MovieTrackingObject *tracking_object, + float mat[4][4]) { - if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) { + if ((tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0) { float smat[4][4]; - scale_m4_fl(smat, 1.0f / object->scale); + scale_m4_fl(smat, 1.0f / tracking_object->scale); mul_m4_m4m4(mat, mat, smat); } } @@ -2184,11 +2180,10 @@ void BKE_tracking_camera_to_blender( BKE_tracking_camera_shift_get(tracking, width, height, &camera->shiftx, &camera->shifty); } -MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(MovieTracking *UNUSED(tracking), - MovieTrackingObject *object, - int framenr) +MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed( + MovieTracking *UNUSED(tracking), MovieTrackingObject *tracking_object, int framenr) { - MovieTrackingReconstruction *reconstruction = &object->reconstruction; + MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction; int a = reconstructed_camera_index_get(reconstruction, framenr, false); if (a == -1) { @@ -2199,11 +2194,11 @@ MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(MovieTracking *U } void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *UNUSED(tracking), - MovieTrackingObject *object, + MovieTrackingObject *tracking_object, float framenr, float mat[4][4]) { - MovieTrackingReconstruction *reconstruction = &object->reconstruction; + MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction; MovieReconstructedCamera *cameras = reconstruction->cameras; int a = reconstructed_camera_index_get(reconstruction, (int)framenr, true); @@ -2222,7 +2217,7 @@ void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *UNUSED(tra copy_m4_m4(mat, cameras[a].mat); } - reconstructed_camera_scale_set(object, mat); + reconstructed_camera_scale_set(tracking_object, mat); } /* -------------------------------------------------------------------- @@ -3157,14 +3152,14 @@ static void tracking_dopesheet_channels_segments_calc(MovieTrackingDopesheetChan /* Create channels for tracks and calculate tracked segments for them. */ static void tracking_dopesheet_channels_calc(MovieTracking *tracking) { - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); MovieTrackingDopesheet *dopesheet = &tracking->dopesheet; - MovieTrackingReconstruction *reconstruction = &object->reconstruction; + MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction; bool sel_only = (dopesheet->flag & TRACKING_DOPE_SELECTED_ONLY) != 0; bool show_hidden = (dopesheet->flag & TRACKING_DOPE_SHOW_HIDDEN) != 0; - LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { if (!show_hidden && (track->flag & TRACK_HIDDEN) != 0) { continue; } @@ -3261,13 +3256,13 @@ static int coverage_from_count(int count) static void tracking_dopesheet_calc_coverage(MovieTracking *tracking) { MovieTrackingDopesheet *dopesheet = &tracking->dopesheet; - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); int frames, start_frame = INT_MAX, end_frame = -INT_MAX; int *per_frame_counter; int prev_coverage, last_segment_frame; /* find frame boundaries */ - LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { start_frame = min_ii(start_frame, track->markers[0].framenr); end_frame = max_ii(end_frame, track->markers[track->markersnr - 1].framenr); } @@ -3283,7 +3278,7 @@ static void tracking_dopesheet_calc_coverage(MovieTracking *tracking) per_frame_counter = MEM_callocN(sizeof(int) * frames, "per frame track counter"); /* find per-frame markers count */ - LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { for (int i = 0; i < track->markersnr; i++) { MovieTrackingMarker *marker = &track->markers[i]; @@ -3369,12 +3364,10 @@ void BKE_tracking_dopesheet_update(MovieTracking *tracking) MovieTrackingObject *BKE_tracking_find_object_for_track(const MovieTracking *tracking, const MovieTrackingTrack *track) { - MovieTrackingObject *object = tracking->objects.first; - while (object != NULL) { - if (BLI_findindex(&object->tracks, track) != -1) { - return object; + LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) { + if (BLI_findindex(&tracking_object->tracks, track) != -1) { + return tracking_object; } - object = object->next; } return NULL; } @@ -3382,21 +3375,19 @@ MovieTrackingObject *BKE_tracking_find_object_for_track(const MovieTracking *tra ListBase *BKE_tracking_find_tracks_list_for_track(MovieTracking *tracking, const MovieTrackingTrack *track) { - MovieTrackingObject *object = BKE_tracking_find_object_for_track(tracking, track); - BLI_assert(object != NULL); + MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(tracking, track); + BLI_assert(tracking_object != NULL); - return &object->tracks; + return &tracking_object->tracks; } MovieTrackingObject *BKE_tracking_find_object_for_plane_track( const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track) { - MovieTrackingObject *object = tracking->objects.first; - while (object != NULL) { - if (BLI_findindex(&object->plane_tracks, plane_track) != -1) { - return object; + LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) { + if (BLI_findindex(&tracking_object->plane_tracks, plane_track) != -1) { + return tracking_object; } - object = object->next; } return NULL; } @@ -3404,10 +3395,11 @@ MovieTrackingObject *BKE_tracking_find_object_for_plane_track( ListBase *BKE_tracking_find_tracks_list_for_plane_track(MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track) { - MovieTrackingObject *object = BKE_tracking_find_object_for_plane_track(tracking, plane_track); - BLI_assert(object != NULL); + MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_plane_track(tracking, + plane_track); + BLI_assert(tracking_object != NULL); - return &object->plane_tracks; + return &tracking_object->plane_tracks; } void BKE_tracking_get_rna_path_for_track(const struct MovieTracking *tracking, @@ -3415,15 +3407,15 @@ void BKE_tracking_get_rna_path_for_track(const struct MovieTracking *tracking, char *rna_path, size_t rna_path_len) { - MovieTrackingObject *object = BKE_tracking_find_object_for_track(tracking, track); + MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(tracking, track); char track_name_esc[MAX_NAME * 2]; BLI_str_escape(track_name_esc, track->name, sizeof(track_name_esc)); - if (object == NULL) { + if (tracking_object == NULL) { BLI_snprintf(rna_path, rna_path_len, "tracking.tracks[\"%s\"]", track_name_esc); } else { char object_name_esc[MAX_NAME * 2]; - BLI_str_escape(object_name_esc, object->name, sizeof(object_name_esc)); + BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc)); BLI_snprintf(rna_path, rna_path_len, "tracking.objects[\"%s\"].tracks[\"%s\"]", @@ -3437,13 +3429,13 @@ void BKE_tracking_get_rna_path_prefix_for_track(const struct MovieTracking *trac char *rna_path, size_t rna_path_len) { - MovieTrackingObject *object = BKE_tracking_find_object_for_track(tracking, track); - if (object == NULL) { + MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(tracking, track); + if (tracking_object == NULL) { BLI_strncpy(rna_path, "tracking.tracks", rna_path_len); } else { char object_name_esc[MAX_NAME * 2]; - BLI_str_escape(object_name_esc, object->name, sizeof(object_name_esc)); + BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc)); BLI_snprintf(rna_path, rna_path_len, "tracking.objects[\"%s\"]", object_name_esc); } } @@ -3453,15 +3445,16 @@ void BKE_tracking_get_rna_path_for_plane_track(const struct MovieTracking *track char *rna_path, size_t rna_path_len) { - MovieTrackingObject *object = BKE_tracking_find_object_for_plane_track(tracking, plane_track); + MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_plane_track(tracking, + plane_track); char track_name_esc[MAX_NAME * 2]; BLI_str_escape(track_name_esc, plane_track->name, sizeof(track_name_esc)); - if (object == NULL) { + if (tracking_object == NULL) { BLI_snprintf(rna_path, rna_path_len, "tracking.plane_tracks[\"%s\"]", track_name_esc); } else { char object_name_esc[MAX_NAME * 2]; - BLI_str_escape(object_name_esc, object->name, sizeof(object_name_esc)); + BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc)); BLI_snprintf(rna_path, rna_path_len, "tracking.objects[\"%s\"].plane_tracks[\"%s\"]", @@ -3476,13 +3469,14 @@ void BKE_tracking_get_rna_path_prefix_for_plane_track( char *rna_path, size_t rna_path_len) { - MovieTrackingObject *object = BKE_tracking_find_object_for_plane_track(tracking, plane_track); - if (object == NULL) { + MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_plane_track(tracking, + plane_track); + if (tracking_object == NULL) { BLI_strncpy(rna_path, "tracking.plane_tracks", rna_path_len); } else { char object_name_esc[MAX_NAME * 2]; - BLI_str_escape(object_name_esc, object->name, sizeof(object_name_esc)); + BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc)); BLI_snprintf(rna_path, rna_path_len, "tracking.objects[\"%s\"].plane_tracks", object_name_esc); } } diff --git a/source/blender/blenkernel/intern/tracking_solver.c b/source/blender/blenkernel/intern/tracking_solver.c index d3323fc939a..8fdcf986a3e 100644 --- a/source/blender/blenkernel/intern/tracking_solver.c +++ b/source/blender/blenkernel/intern/tracking_solver.c @@ -131,14 +131,15 @@ static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, int sfra = context->sfra, efra = context->efra; float imat[4][4]; - MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name); - MovieTrackingReconstruction *reconstruction = &object->reconstruction; + MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, + context->object_name); + MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction; unit_m4(imat); { int track_index = 0; - LISTBASE_FOREACH_INDEX (MovieTrackingTrack *, track, &object->tracks, track_index) { + LISTBASE_FOREACH_INDEX (MovieTrackingTrack *, track, &tracking_object->tracks, track_index) { double pos[3]; if (libmv_reprojectionPointForTrack(libmv_reconstruction, track_index, pos)) { @@ -221,7 +222,7 @@ static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, } if (origin_set) { - LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { if (track->flag & TRACK_HAS_BUNDLE) { mul_v3_m4v3(track->bundle_pos, imat, track->bundle_pos); } @@ -244,12 +245,12 @@ static int reconstruct_retrieve_libmv(MovieReconstructContext *context, MovieTra /* Convert blender's refinement flags to libmv's. */ static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking, - MovieTrackingObject *object) + MovieTrackingObject *tracking_object) { - int refine = tracking->settings.refine_camera_intrinsics; + const int refine = tracking->settings.refine_camera_intrinsics; int flags = 0; - if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) { + if ((tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0) { return 0; } @@ -273,12 +274,12 @@ static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking, } /* Count tracks which has markers at both of keyframes. */ -static int reconstruct_count_tracks_on_both_keyframes(MovieTrackingObject *object) +static int reconstruct_count_tracks_on_both_keyframes(MovieTrackingObject *tracking_object) { - const int frame1 = object->keyframe1, frame2 = object->keyframe2; + const int frame1 = tracking_object->keyframe1, frame2 = tracking_object->keyframe2; int tot = 0; - LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame1)) { if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame2)) { tot++; @@ -290,7 +291,7 @@ static int reconstruct_count_tracks_on_both_keyframes(MovieTrackingObject *objec } bool BKE_tracking_reconstruction_check(MovieTracking *tracking, - MovieTrackingObject *object, + MovieTrackingObject *tracking_object, char *error_msg, int error_size) { @@ -300,7 +301,7 @@ bool BKE_tracking_reconstruction_check(MovieTracking *tracking, } if ((tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) == 0) { /* automatic keyframe selection does not require any pre-process checks */ - if (reconstruct_count_tracks_on_both_keyframes(object) < 8) { + if (reconstruct_count_tracks_on_both_keyframes(tracking_object) < 8) { BLI_strncpy(error_msg, N_("At least 8 common tracks on both keyframes are needed for reconstruction"), error_size); @@ -317,21 +318,22 @@ bool BKE_tracking_reconstruction_check(MovieTracking *tracking, return true; } -MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip, - MovieTrackingObject *object, - int keyframe1, - int keyframe2, - int width, - int height) +MovieReconstructContext *BKE_tracking_reconstruction_context_new( + MovieClip *clip, + MovieTrackingObject *tracking_object, + int keyframe1, + int keyframe2, + int width, + int height) { MovieTracking *tracking = &clip->tracking; MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext), "MovieReconstructContext data"); const float aspy = 1.0f / tracking->camera.pixel_aspect; - const int num_tracks = BLI_listbase_count(&object->tracks); + const int num_tracks = BLI_listbase_count(&tracking_object->tracks); int sfra = INT_MAX, efra = INT_MIN; - BLI_strncpy(context->object_name, object->name, sizeof(context->object_name)); + BLI_strncpy(context->object_name, tracking_object->name, sizeof(context->object_name)); context->motion_flag = tracking->settings.motion_flag; context->select_keyframes = (tracking->settings.reconstruction_flag & @@ -342,7 +344,7 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip context->tracks_map = tracks_map_new(context->object_name, num_tracks, 0); - LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { int first = 0, last = track->markersnr - 1; MovieTrackingMarker *first_marker = &track->markers[0]; MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1]; @@ -373,10 +375,10 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip context->sfra = sfra; context->efra = efra; - context->tracks = libmv_tracks_new(clip, &object->tracks, width, height * aspy); + context->tracks = libmv_tracks_new(clip, &tracking_object->tracks, width, height * aspy); context->keyframe1 = keyframe1; context->keyframe2 = keyframe2; - context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, object); + context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, tracking_object); context->error_message[0] = '\0'; @@ -495,13 +497,14 @@ bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieT tracks_map_merge(context->tracks_map, tracking); BKE_tracking_dopesheet_tag_update(tracking); - MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name); - MovieTrackingReconstruction *reconstruction = &object->reconstruction; + MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, + context->object_name); + MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction; /* update keyframe in the interface */ if (context->select_keyframes) { - object->keyframe1 = context->keyframe1; - object->keyframe2 = context->keyframe2; + tracking_object->keyframe1 = context->keyframe1; + tracking_object->keyframe2 = context->keyframe2; } reconstruction->error = context->reprojection_error; diff --git a/source/blender/blenkernel/intern/tracking_util.c b/source/blender/blenkernel/intern/tracking_util.c index a1637b63d82..fa36d8d2c02 100644 --- a/source/blender/blenkernel/intern/tracking_util.c +++ b/source/blender/blenkernel/intern/tracking_util.c @@ -110,13 +110,13 @@ void tracks_map_merge(TracksMap *map, MovieTracking *tracking) ListBase tracks = {NULL, NULL}, new_tracks = {NULL, NULL}; ListBase *old_tracks; - MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name); - if (!object) { + MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, map->object_name); + if (!tracking_object) { /* object was deleted by user, create new one */ - object = BKE_tracking_object_add(tracking, map->object_name); + tracking_object = BKE_tracking_object_add(tracking, map->object_name); } - old_tracks = &object->tracks; + old_tracks = &tracking_object->tracks; /* duplicate currently operating tracks to temporary list. * this is needed to keep names in unique state and it's faster to change names diff --git a/source/blender/blenloader/intern/versioning_260.c b/source/blender/blenloader/intern/versioning_260.c index 31a3981feaa..ad7d08270c2 100644 --- a/source/blender/blenloader/intern/versioning_260.c +++ b/source/blender/blenloader/intern/versioning_260.c @@ -1732,18 +1732,13 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain) } if (!MAIN_VERSION_ATLEAST(bmain, 264, 7)) { - MovieClip *clip; - - for (clip = bmain->movieclips.first; clip; clip = clip->id.next) { - MovieTrackingTrack *track; - MovieTrackingObject *object; - - for (track = clip->tracking.tracks_legacy.first; track; track = track->next) { + LISTBASE_FOREACH (MovieClip *, clip, &bmain->movieclips) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &clip->tracking.tracks_legacy) { do_versions_affine_tracker_track(track); } - for (object = clip->tracking.objects.first; object; object = object->next) { - for (track = object->tracks.first; track; track = track->next) { + LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &clip->tracking.objects) { + LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) { do_versions_affine_tracker_track(track); } } diff --git a/source/blender/compositor/operations/COM_PlaneTrackOperation.cc b/source/blender/compositor/operations/COM_PlaneTrackOperation.cc index f5922d54fc9..58302510791 100644 --- a/source/blender/compositor/operations/COM_PlaneTrackOperation.cc +++ b/source/blender/compositor/operations/COM_PlaneTrackOperation.cc @@ -42,19 +42,17 @@ void PlaneTrackCommon::read_and_calculate_corners(PlaneDistortBaseOperation *dis void PlaneTrackCommon::read_corners_from_track(float corners[4][2], float frame) { - MovieTracking *tracking; - MovieTrackingObject *object; - if (!movie_clip_) { return; } - tracking = &movie_clip_->tracking; + MovieTracking *tracking = &movie_clip_->tracking; - object = BKE_tracking_object_get_named(tracking, tracking_object_name_); - if (object) { + MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, + tracking_object_name_); + if (tracking_object) { MovieTrackingPlaneTrack *plane_track; - plane_track = BKE_tracking_plane_track_get_named(tracking, object, plane_track_name_); + plane_track = BKE_tracking_plane_track_get_named(tracking, tracking_object, plane_track_name_); if (plane_track) { float clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, frame); BKE_tracking_plane_marker_get_subframe_corners(plane_track, clip_framenr, corners); diff --git a/source/blender/compositor/operations/COM_TrackPositionOperation.cc b/source/blender/compositor/operations/COM_TrackPositionOperation.cc index db65edca31b..d8c4b4f3ddb 100644 --- a/source/blender/compositor/operations/COM_TrackPositionOperation.cc +++ b/source/blender/compositor/operations/COM_TrackPositionOperation.cc @@ -36,9 +36,7 @@ void TrackPositionOperation::init_execution() void TrackPositionOperation::calc_track_position() { is_track_position_calculated_ = true; - MovieTracking *tracking = nullptr; MovieClipUser user = *DNA_struct_default_get(MovieClipUser); - MovieTrackingObject *object; track_position_ = 0; zero_v2(marker_pos_); @@ -48,16 +46,16 @@ void TrackPositionOperation::calc_track_position() return; } - tracking = &movie_clip_->tracking; + MovieTracking *tracking = &movie_clip_->tracking; BKE_movieclip_user_set_frame(&user, framenumber_); BKE_movieclip_get_size(movie_clip_, &user, &width_, &height_); - object = BKE_tracking_object_get_named(tracking, tracking_object_name_); - if (object) { - MovieTrackingTrack *track; - - track = BKE_tracking_track_get_named(tracking, object, track_name_); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, + tracking_object_name_); + if (tracking_object) { + MovieTrackingTrack *track = BKE_tracking_track_get_named( + tracking, tracking_object, track_name_); if (track) { MovieTrackingMarker *marker; diff --git a/source/blender/editors/space_clip/clip_dopesheet_ops.c b/source/blender/editors/space_clip/clip_dopesheet_ops.c index dc6ac59de98..c9716f80f37 100644 --- a/source/blender/editors/space_clip/clip_dopesheet_ops.c +++ b/source/blender/editors/space_clip/clip_dopesheet_ops.c @@ -62,7 +62,7 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op) SpaceClip *sc = CTX_wm_space_clip(C); MovieClip *clip = ED_space_clip_get_clip(sc); MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); MovieTrackingDopesheet *dopesheet = &tracking->dopesheet; float location[2]; const bool extend = RNA_boolean_get(op->ptr, "extend"); @@ -84,8 +84,8 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op) } if (track->flag & TRACK_DOPE_SEL) { - object->active_track = track; - BKE_tracking_track_select(&object->tracks, track, TRACK_AREA_ALL, true); + tracking_object->active_track = track; + BKE_tracking_track_select(&tracking_object->tracks, track, TRACK_AREA_ALL, true); } else if (show_selected_only == false) { BKE_tracking_track_deselect(track, TRACK_AREA_ALL); diff --git a/source/blender/editors/space_clip/clip_draw.c b/source/blender/editors/space_clip/clip_draw.c index b7f09af2636..ca6aba71651 100644 --- a/source/blender/editors/space_clip/clip_draw.c +++ b/source/blender/editors/space_clip/clip_draw.c @@ -1592,13 +1592,13 @@ static void draw_tracking_tracks(SpaceClip *sc, } if (sc->flag & SC_SHOW_BUNDLES) { - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); float pos[4], vec[4], mat[4][4], aspy; GPU_point_size(3.0f); aspy = 1.0f / clip->tracking.camera.pixel_aspect; - BKE_tracking_get_projection_matrix(tracking, object, framenr, width, height, mat); + BKE_tracking_get_projection_matrix(tracking, tracking_object, framenr, width, height, mat); track = tracksbase->first; while (track) { diff --git a/source/blender/editors/space_clip/clip_graph_ops.c b/source/blender/editors/space_clip/clip_graph_ops.c index ce718bbd1c0..dab3b92ebbd 100644 --- a/source/blender/editors/space_clip/clip_graph_ops.c +++ b/source/blender/editors/space_clip/clip_graph_ops.c @@ -247,11 +247,11 @@ static bool mouse_select_curve(bContext *C, const float co[2], bool extend) } else if (act_track != userdata.track) { SelectUserData selectdata = {SEL_DESELECT}; - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); - object->active_track = userdata.track; + tracking_object->active_track = userdata.track; if ((sc->flag & SC_SHOW_GRAPH_SEL_ONLY) == 0) { - BKE_tracking_track_select(&object->tracks, userdata.track, TRACK_AREA_ALL, false); + BKE_tracking_track_select(&tracking_object->tracks, userdata.track, TRACK_AREA_ALL, false); } /* deselect all knots on newly selected curve */ diff --git a/source/blender/editors/space_clip/tracking_ops.c b/source/blender/editors/space_clip/tracking_ops.c index 4c028500e30..eba7ab20123 100644 --- a/source/blender/editors/space_clip/tracking_ops.c +++ b/source/blender/editors/space_clip/tracking_ops.c @@ -1619,15 +1619,15 @@ static int set_solver_keyframe_exec(bContext *C, wmOperator *op) SpaceClip *sc = CTX_wm_space_clip(C); MovieClip *clip = ED_space_clip_get_clip(sc); MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); - int keyframe = RNA_enum_get(op->ptr, "keyframe"); - int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, sc->user.framenr); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); + const int keyframe = RNA_enum_get(op->ptr, "keyframe"); + const int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, sc->user.framenr); if (keyframe == SOLVER_KEYFRAME_A) { - object->keyframe1 = framenr; + tracking_object->keyframe1 = framenr; } else { - object->keyframe2 = framenr; + tracking_object->keyframe2 = framenr; } WM_event_add_notifier(C, NC_MOVIECLIP | ND_DISPLAY, clip); @@ -1992,16 +1992,14 @@ static int tracking_object_remove_exec(bContext *C, wmOperator *op) SpaceClip *sc = CTX_wm_space_clip(C); MovieClip *clip = ED_space_clip_get_clip(sc); MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object; + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); - object = BKE_tracking_object_get_active(tracking); - - if (object->flag & TRACKING_OBJECT_CAMERA) { + if (tracking_object->flag & TRACKING_OBJECT_CAMERA) { BKE_report(op->reports, RPT_WARNING, "Object used for camera tracking cannot be deleted"); return OPERATOR_CANCELLED; } - BKE_tracking_object_delete(tracking, object); + BKE_tracking_object_delete(tracking, tracking_object); DEG_id_tag_update(&clip->id, ID_RECALC_COPY_ON_WRITE); WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip); @@ -2035,11 +2033,11 @@ static int copy_tracks_exec(bContext *C, wmOperator *UNUSED(op)) SpaceClip *sc = CTX_wm_space_clip(C); MovieClip *clip = ED_space_clip_get_clip(sc); MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); clip_tracking_clear_invisible_track_selection(sc, clip); - BKE_tracking_clipboard_copy_tracks(tracking, object); + BKE_tracking_clipboard_copy_tracks(tracking, tracking_object); return OPERATOR_FINISHED; } diff --git a/source/blender/editors/space_clip/tracking_ops_solve.c b/source/blender/editors/space_clip/tracking_ops_solve.c index ddfcaa282e3..3fedf97f51b 100644 --- a/source/blender/editors/space_clip/tracking_ops_solve.c +++ b/source/blender/editors/space_clip/tracking_ops_solve.c @@ -53,10 +53,10 @@ static bool solve_camera_initjob( MovieClip *clip = ED_space_clip_get_clip(sc); Scene *scene = CTX_data_scene(C); MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object = BKE_tracking_object_get_active(tracking); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking); int width, height; - if (!BKE_tracking_reconstruction_check(tracking, object, error_msg, max_error)) { + if (!BKE_tracking_reconstruction_check(tracking, tracking_object, error_msg, max_error)) { return false; } @@ -69,8 +69,12 @@ static bool solve_camera_initjob( scj->reports = op->reports; scj->user = sc->user; - scj->context = BKE_tracking_reconstruction_context_new( - clip, object, object->keyframe1, object->keyframe2, width, height); + scj->context = BKE_tracking_reconstruction_context_new(clip, + tracking_object, + tracking_object->keyframe1, + tracking_object->keyframe2, + width, + height); tracking->stats = MEM_callocN(sizeof(MovieTrackingStats), "solve camera stats"); diff --git a/source/blender/makesrna/intern/rna_mask.c b/source/blender/makesrna/intern/rna_mask.c index 3dac148f7d4..2303cde997f 100644 --- a/source/blender/makesrna/intern/rna_mask.c +++ b/source/blender/makesrna/intern/rna_mask.c @@ -59,14 +59,15 @@ static void rna_Mask_update_parent(Main *bmain, Scene *scene, PointerRNA *ptr) if (GS(parent->id->name) == ID_MC) { MovieClip *clip = (MovieClip *)parent->id; MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, parent->parent); + MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, + parent->parent); - if (object) { + if (tracking_object) { int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, scene->r.cfra); if (parent->type == MASK_PARENT_POINT_TRACK) { MovieTrackingTrack *track = BKE_tracking_track_get_named( - tracking, object, parent->sub_parent); + tracking, tracking_object, parent->sub_parent); if (track) { MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_framenr); @@ -84,7 +85,7 @@ static void rna_Mask_update_parent(Main *bmain, Scene *scene, PointerRNA *ptr) } else /* if (parent->type == MASK_PARENT_PLANE_TRACK) */ { MovieTrackingPlaneTrack *plane_track = BKE_tracking_plane_track_get_named( - tracking, object, parent->sub_parent); + tracking, tracking_object, parent->sub_parent); if (plane_track) { MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, clip_framenr); diff --git a/source/blender/makesrna/intern/rna_tracking.c b/source/blender/makesrna/intern/rna_tracking.c index 7250b1272e7..f262eda1fc4 100644 --- a/source/blender/makesrna/intern/rna_tracking.c +++ b/source/blender/makesrna/intern/rna_tracking.c @@ -434,30 +434,31 @@ static void rna_tracking_resetIntrinsics(Main *UNUSED(bmain), static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr) { - MovieTrackingObject *object = (MovieTrackingObject *)ptr->data; - rna_iterator_listbase_begin(iter, &object->tracks, NULL); + MovieTrackingObject *tracking_object = (MovieTrackingObject *)ptr->data; + rna_iterator_listbase_begin(iter, &tracking_object->tracks, NULL); } static void rna_trackingObject_plane_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr) { - MovieTrackingObject *object = (MovieTrackingObject *)ptr->data; - rna_iterator_listbase_begin(iter, &object->plane_tracks, NULL); + MovieTrackingObject *tracking_object = (MovieTrackingObject *)ptr->data; + rna_iterator_listbase_begin(iter, &tracking_object->plane_tracks, NULL); } static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr) { - MovieTrackingObject *object = (MovieTrackingObject *)ptr->data; + MovieTrackingObject *tracking_object = (MovieTrackingObject *)ptr->data; return rna_pointer_inherit_refine( - ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction); + ptr, &RNA_MovieTrackingReconstruction, &tracking_object->reconstruction); } static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr) { MovieClip *clip = (MovieClip *)ptr->owner_id; - MovieTrackingObject *object = BLI_findlink(&clip->tracking.objects, clip->tracking.objectnr); + MovieTrackingObject *tracking_object = BLI_findlink(&clip->tracking.objects, + clip->tracking.objectnr); - return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, object); + return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, tracking_object); } static void rna_tracking_active_object_set(PointerRNA *ptr, @@ -465,8 +466,8 @@ static void rna_tracking_active_object_set(PointerRNA *ptr, struct ReportList *UNUSED(reports)) { MovieClip *clip = (MovieClip *)ptr->owner_id; - MovieTrackingObject *object = (MovieTrackingObject *)value.data; - int index = BLI_findindex(&clip->tracking.objects, object); + MovieTrackingObject *tracking_object = (MovieTrackingObject *)value.data; + const int index = BLI_findindex(&clip->tracking.objects, tracking_object); if (index != -1) { clip->tracking.objectnr = index; @@ -479,11 +480,11 @@ static void rna_tracking_active_object_set(PointerRNA *ptr, static void rna_trackingObject_name_set(PointerRNA *ptr, const char *value) { MovieClip *clip = (MovieClip *)ptr->owner_id; - MovieTrackingObject *object = (MovieTrackingObject *)ptr->data; + MovieTrackingObject *tracking_object = (MovieTrackingObject *)ptr->data; - BLI_strncpy(object->name, value, sizeof(object->name)); + BLI_strncpy(tracking_object->name, value, sizeof(tracking_object->name)); - BKE_tracking_object_unique_name(&clip->tracking, object); + BKE_tracking_object_unique_name(&clip->tracking, tracking_object); } static void rna_trackingObject_flushUpdate(Main *UNUSED(bmain), @@ -603,13 +604,13 @@ static MovieTrackingTrack *rna_trackingTracks_new(ID *id, } static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id, - MovieTrackingObject *object, + MovieTrackingObject *tracking_object, const char *name, int frame) { MovieClip *clip = (MovieClip *)id; MovieTrackingTrack *track = add_track_to_base( - clip, &clip->tracking, &object->tracks, name, frame); + clip, &clip->tracking, &tracking_object->tracks, name, frame); WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL); @@ -618,20 +619,20 @@ static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id, static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name) { - MovieTrackingObject *object = BKE_tracking_object_add(tracking, name); + MovieTrackingObject *tracking_object = BKE_tracking_object_add(tracking, name); WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL); - return object; + return tracking_object; } static void rna_trackingObject_remove(MovieTracking *tracking, ReportList *reports, PointerRNA *object_ptr) { - MovieTrackingObject *object = object_ptr->data; - if (BKE_tracking_object_delete(tracking, object) == false) { - BKE_reportf(reports, RPT_ERROR, "MovieTracking '%s' cannot be removed", object->name); + MovieTrackingObject *tracking_object = object_ptr->data; + if (BKE_tracking_object_delete(tracking, tracking_object) == false) { + BKE_reportf(reports, RPT_ERROR, "MovieTracking '%s' cannot be removed", tracking_object->name); return; } @@ -735,11 +736,9 @@ static void rna_trackingPlaneMarkers_delete_frame(MovieTrackingPlaneTrack *plane static MovieTrackingObject *find_object_for_reconstruction( MovieTracking *tracking, MovieTrackingReconstruction *reconstruction) { - MovieTrackingObject *object; - - for (object = tracking->objects.first; object; object = object->next) { - if (&object->reconstruction == reconstruction) { - return object; + LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) { + if (&tracking_object->reconstruction == reconstruction) { + return tracking_object; } } @@ -751,8 +750,8 @@ static MovieReconstructedCamera *rna_trackingCameras_find_frame( { MovieClip *clip = (MovieClip *)id; MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object = find_object_for_reconstruction(tracking, reconstruction); - return BKE_tracking_camera_get_reconstructed(tracking, object, framenr); + MovieTrackingObject *tracking_object = find_object_for_reconstruction(tracking, reconstruction); + return BKE_tracking_camera_get_reconstructed(tracking, tracking_object, framenr); } static void rna_trackingCameras_matrix_from_frame(ID *id, @@ -764,8 +763,8 @@ static void rna_trackingCameras_matrix_from_frame(ID *id, MovieClip *clip = (MovieClip *)id; MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object = find_object_for_reconstruction(tracking, reconstruction); - BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat); + MovieTrackingObject *tracking_object = find_object_for_reconstruction(tracking, reconstruction); + BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, mat); memcpy(matrix, mat, sizeof(float[4][4])); } diff --git a/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc b/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc index 68dc020a02e..a5cc9b01a1c 100644 --- a/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc +++ b/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc @@ -79,7 +79,7 @@ static void node_composit_buts_planetrackdeform(uiLayout *layout, bContext *C, P if (node->id) { MovieClip *clip = (MovieClip *)node->id; MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object; + MovieTrackingObject *tracking_object; uiLayout *col; PointerRNA tracking_ptr; @@ -88,11 +88,11 @@ static void node_composit_buts_planetrackdeform(uiLayout *layout, bContext *C, P col = uiLayoutColumn(layout, false); uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA); - object = BKE_tracking_object_get_named(tracking, data->tracking_object); - if (object) { + tracking_object = BKE_tracking_object_get_named(tracking, data->tracking_object); + if (tracking_object) { PointerRNA object_ptr; - RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, object, &object_ptr); + RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, tracking_object, &object_ptr); uiItemPointerR( col, ptr, "plane_track_name", &object_ptr, "plane_tracks", "", ICON_ANIM_DATA); diff --git a/source/blender/nodes/composite/nodes/node_composite_trackpos.cc b/source/blender/nodes/composite/nodes/node_composite_trackpos.cc index 0e9bd800f44..10c5008b85e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_trackpos.cc +++ b/source/blender/nodes/composite/nodes/node_composite_trackpos.cc @@ -74,7 +74,7 @@ static void node_composit_buts_trackpos(uiLayout *layout, bContext *C, PointerRN if (node->id) { MovieClip *clip = (MovieClip *)node->id; MovieTracking *tracking = &clip->tracking; - MovieTrackingObject *object; + MovieTrackingObject *tracking_object; uiLayout *col; PointerRNA tracking_ptr; NodeTrackPosData *data = (NodeTrackPosData *)node->storage; @@ -84,11 +84,11 @@ static void node_composit_buts_trackpos(uiLayout *layout, bContext *C, PointerRN col = uiLayoutColumn(layout, false); uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA); - object = BKE_tracking_object_get_named(tracking, data->tracking_object); - if (object) { + tracking_object = BKE_tracking_object_get_named(tracking, data->tracking_object); + if (tracking_object) { PointerRNA object_ptr; - RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, object, &object_ptr); + RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, tracking_object, &object_ptr); uiItemPointerR(col, ptr, "track_name", &object_ptr, "tracks", "", ICON_ANIM_DATA); }