archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Cleanup: Variable naming in tracking files

Browse Source 
Make it obvious that the object is the motion tracking one, and
not the ID_OB type.
This commit is contained in:
Sergey Sharybin
2022-10-05 18:01:29 +02:00
parent 953f719e58
commit 016f9c2cf5
17 changed files with 251 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
source/blender/blenkernel/BKE_tracking.h
View File

@@ -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,

16
source/blender/blenkernel/intern/constraint.c
View File

@@ -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);

238
source/blender/blenkernel/intern/tracking.c
View File

@@ -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);
}
}

57
source/blender/blenkernel/intern/tracking_solver.c
View File

@@ -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;

8
source/blender/blenkernel/intern/tracking_util.c
View File

@@ -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

13
source/blender/blenloader/intern/versioning_260.c
View File

@@ -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);
}
}

12
source/blender/compositor/operations/COM_PlaneTrackOperation.cc
View File

@@ -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);

14
source/blender/compositor/operations/COM_TrackPositionOperation.cc
View File

@@ -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;

6
source/blender/editors/space_clip/clip_dopesheet_ops.c
View File

@@ -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);

4
source/blender/editors/space_clip/clip_draw.c
View File

@@ -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) {

6
source/blender/editors/space_clip/clip_graph_ops.c
View File

@@ -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 */

22
source/blender/editors/space_clip/tracking_ops.c
View File

@@ -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;
}

12
source/blender/editors/space_clip/tracking_ops_solve.c
View File

@@ -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");

9
source/blender/makesrna/intern/rna_mask.c
View File

@@ -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);

57
source/blender/makesrna/intern/rna_tracking.c
View File

@@ -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]));
}

8
source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc
View File

@@ -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);

8
source/blender/nodes/composite/nodes/node_composite_trackpos.cc
View File

@@ -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);
}