Blender  V3.3
tracking_ops_orient.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2016 Blender Foundation. All rights reserved. */
3 
8 #include "MEM_guardedalloc.h"
9 
10 #include "DNA_constraint_types.h"
11 #include "DNA_object_types.h" /* SELECT */
12 #include "DNA_screen_types.h"
13 #include "DNA_space_types.h"
14 
15 #include "BLI_math.h"
16 #include "BLI_utildefines.h"
17 
18 #include "BKE_constraint.h"
19 #include "BKE_context.h"
20 #include "BKE_layer.h"
21 #include "BKE_object.h"
22 #include "BKE_report.h"
23 #include "BKE_tracking.h"
24 
25 #include "DEG_depsgraph.h"
26 #include "DEG_depsgraph_query.h"
27 
28 #include "WM_api.h"
29 #include "WM_types.h"
30 
31 #include "ED_clip.h"
32 
33 #include "RNA_access.h"
34 #include "RNA_define.h"
35 
36 #include "clip_intern.h"
37 
38 /********************** set origin operator *********************/
39 
41 {
43 
44  if (camera != NULL && BKE_object_movieclip_get(scene, camera, false) == clip) {
45  return camera;
46  }
47 
49  if (ob->type == OB_CAMERA) {
50  if (BKE_object_movieclip_get(scene, ob, false) == clip) {
51  camera = ob;
52  break;
53  }
54  }
55  }
57 
58  return camera;
59 }
60 
62 {
64  ViewLayer *view_layer = CTX_data_view_layer(C);
67  MovieTracking *tracking = &clip->tracking;
68  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
69  Object *object = NULL;
70 
71  if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
72  object = get_camera_with_movieclip(scene, clip);
73  }
74  else {
75  object = OBACT(view_layer);
76  }
77 
78  if (object != NULL && object->parent != NULL) {
79  object = object->parent;
80  }
81 
82  return object;
83 }
84 
86 {
88  if (sc != NULL) {
89  ViewLayer *view_layer = CTX_data_view_layer(C);
91  if (clip != NULL) {
92  MovieTracking *tracking = &clip->tracking;
93  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
94  if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
95  return true;
96  }
97  return OBACT(view_layer) != NULL;
98  }
99  }
100  return false;
101 }
102 
104 {
106  MovieClip *clip = ED_space_clip_get_clip(sc);
107  ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
108  int tot = 0;
109  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {
110  if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_HAS_BUNDLE)) {
111  tot++;
112  }
113  }
114  return tot;
115 }
116 
117 static void object_solver_inverted_matrix(Scene *scene, Object *ob, float invmat[4][4])
118 {
119  bool found = false;
120  for (bConstraint *con = ob->constraints.first; con != NULL; con = con->next) {
122  if (cti == NULL) {
123  continue;
124  }
125  if (cti->type == CONSTRAINT_TYPE_OBJECTSOLVER) {
127  if (!found) {
128  Object *cam = data->camera ? data->camera : scene->camera;
129  BKE_object_where_is_calc_mat4(cam, invmat);
130  }
131  mul_m4_m4m4(invmat, invmat, data->invmat);
132  found = true;
133  }
134  }
135  if (found) {
136  invert_m4(invmat);
137  }
138  else {
139  unit_m4(invmat);
140  }
141 }
142 
144 {
145  for (bConstraint *con = ob->constraints.first; con != NULL; con = con->next) {
147  if (cti == NULL) {
148  continue;
149  }
150  if (cti->type == CONSTRAINT_TYPE_OBJECTSOLVER) {
152  return (data->camera != NULL) ? data->camera : scene->camera;
153  }
154  }
155  return NULL;
156 }
157 
159 {
161  MovieClip *clip = ED_space_clip_get_clip(sc);
162  MovieTracking *tracking = &clip->tracking;
165  int selected_count = count_selected_bundles(C);
166 
167  if (selected_count == 0) {
168  BKE_report(op->reports,
169  RPT_ERROR,
170  "At least one track with bundle should be selected to "
171  "define origin position");
172 
173  return OPERATOR_CANCELLED;
174  }
175 
176  Object *object = get_orientation_object(C);
177  if (object == NULL) {
178  BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
179  return OPERATOR_CANCELLED;
180  }
181 
182  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
183  ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
184 
185  float median[3] = {0.0f, 0.0f, 0.0f};
186  zero_v3(median);
187  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {
188  if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_HAS_BUNDLE)) {
189  add_v3_v3(median, track->bundle_pos);
190  }
191  }
192  mul_v3_fl(median, 1.0f / selected_count);
193 
194  float mat[4][4], vec[3];
196  mul_v3_m4v3(vec, mat, median);
197 
198  if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
199  sub_v3_v3(object->loc, vec);
200  }
201  else {
202  object_solver_inverted_matrix(scene, object, mat);
203  mul_v3_m4v3(vec, mat, vec);
204  copy_v3_v3(object->loc, vec);
205  }
206 
207  DEG_id_tag_update(&clip->id, 0);
209 
212 
213  return OPERATOR_FINISHED;
214 }
215 
217 {
218  /* identifiers */
219  ot->name = "Set Origin";
220  ot->description =
221  "Set active marker as origin by moving camera (or its parent if present) in 3D space";
222  ot->idname = "CLIP_OT_set_origin";
223 
224  /* api callbacks */
227 
228  /* flags */
230 
231  /* properties */
233  ot->srna, "use_median", 0, "Use Median", "Set origin to median point of selected bundles");
234 }
235 
236 /********************** set floor operator *********************/
237 
238 static void set_axis(Scene *scene,
239  Object *ob,
240  MovieClip *clip,
241  MovieTrackingObject *tracking_object,
242  MovieTrackingTrack *track,
243  char axis)
244 {
246  const bool is_camera = (tracking_object->flag & TRACKING_OBJECT_CAMERA) != 0;
247  bool flip = false;
248  float mat[4][4], vec[3], obmat[4][4], dvec[3];
249 
250  BKE_object_to_mat4(ob, obmat);
251 
253  mul_v3_m4v3(vec, mat, track->bundle_pos);
254  copy_v3_v3(dvec, vec);
255 
256  if (!is_camera) {
257  float imat[4][4];
258 
260  mul_v3_m4v3(vec, imat, vec);
261 
262  invert_m4_m4(imat, obmat);
263  mul_v3_m4v3(dvec, imat, vec);
264 
265  sub_v3_v3(vec, obmat[3]);
266  }
267 
268  if (len_squared_v2(vec) < (1e-3f * 1e-3f)) {
269  return;
270  }
271 
272  unit_m4(mat);
273 
274  if (axis == 'X') {
275  if (fabsf(dvec[1]) < 1e-3f) {
276  flip = true;
277 
278  mat[0][0] = -1.0f;
279  mat[0][1] = 0.0f;
280  mat[0][2] = 0.0f;
281  mat[1][0] = 0.0f;
282  mat[1][1] = -1.0f;
283  mat[1][2] = 0.0f;
284  mat[2][0] = 0.0f;
285  mat[2][1] = 0.0f;
286  mat[2][2] = 1.0f;
287  }
288  else {
289  copy_v3_v3(mat[0], vec);
290 
291  if (is_camera || fabsf(vec[2]) < 1e-3f) {
292  mat[0][2] = 0.0f;
293  mat[2][0] = 0.0f;
294  mat[2][1] = 0.0f;
295  mat[2][2] = 1.0f;
296  cross_v3_v3v3(mat[1], mat[2], mat[0]);
297  }
298  else {
299  vec[2] = 0.0f;
300 
301  cross_v3_v3v3(mat[1], mat[0], vec);
302  cross_v3_v3v3(mat[2], mat[0], mat[1]);
303  }
304  }
305  }
306  else {
307  if (fabsf(dvec[0]) < 1e-3f) {
308  flip = true;
309 
310  mat[0][0] = -1.0f;
311  mat[0][1] = 0.0f;
312  mat[0][2] = 0.0f;
313  mat[1][0] = 0.0f;
314  mat[1][1] = -1.0f;
315  mat[1][2] = 0.0f;
316  mat[2][0] = 0.0f;
317  mat[2][1] = 0.0f;
318  mat[2][2] = 1.0f;
319  }
320  else {
321  copy_v3_v3(mat[1], vec);
322 
323  if (is_camera || fabsf(vec[2]) < 1e-3f) {
324  mat[1][2] = 0.0f;
325  mat[2][0] = 0.0f;
326  mat[2][1] = 0.0f;
327  mat[2][2] = 1.0f;
328  cross_v3_v3v3(mat[0], mat[1], mat[2]);
329  }
330  else {
331  vec[2] = 0.0f;
332 
333  cross_v3_v3v3(mat[0], vec, mat[1]);
334  cross_v3_v3v3(mat[2], mat[0], mat[1]);
335  }
336  }
337  }
338 
339  normalize_v3(mat[0]);
340  normalize_v3(mat[1]);
341  normalize_v3(mat[2]);
342 
343  if (is_camera) {
344  invert_m4(mat);
345 
346  mul_m4_m4m4(mat, mat, obmat);
347  }
348  else {
349  if (!flip) {
350  float lmat[4][4], ilmat[4][4], rmat[3][3];
351 
352  BKE_object_rot_to_mat3(ob, rmat, true);
353  invert_m3(rmat);
354  mul_m4_m4m3(mat, mat, rmat);
355 
356  unit_m4(lmat);
357  copy_v3_v3(lmat[3], obmat[3]);
358  invert_m4_m4(ilmat, lmat);
359 
360  mul_m4_series(mat, lmat, mat, ilmat, obmat);
361  }
362  else {
363  mul_m4_m4m4(mat, obmat, mat);
364  }
365  }
366 
367  BKE_object_apply_mat4(ob, mat, 0, 0);
368 }
369 
371 {
373  MovieClip *clip = ED_space_clip_get_clip(sc);
375  MovieTracking *tracking = &clip->tracking;
376  MovieTrackingObject *tracking_object;
377  MovieTrackingTrack *track, *axis_track = NULL, *act_track;
378  ListBase *tracksbase;
379  Object *object;
381  int tot = 0;
382  float vec[3][3], mat[4][4], obmat[4][4], newmat[4][4], orig[3] = {0.0f, 0.0f, 0.0f};
383  int plane = RNA_enum_get(op->ptr, "plane");
384  float rot[4][4] = {
385  {0.0f, 0.0f, -1.0f, 0.0f},
386  {0.0f, 1.0f, 0.0f, 0.0f},
387  {1.0f, 0.0f, 0.0f, 0.0f},
388  {0.0f, 0.0f, 0.0f, 1.0f},
389  }; /* 90 degrees Y-axis rotation matrix */
390 
391  if (count_selected_bundles(C) != 3) {
392  BKE_report(op->reports, RPT_ERROR, "Three tracks with bundles are needed to orient the floor");
393 
394  return OPERATOR_CANCELLED;
395  }
396 
397  tracking_object = BKE_tracking_object_get_active(tracking);
398  tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
399  act_track = BKE_tracking_track_get_active(tracking);
400 
401  object = get_orientation_object(C);
402  if (object == NULL) {
403  BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
404  return OPERATOR_CANCELLED;
405  }
406 
408 
409  /* Get 3 bundles to use as reference. */
410  track = tracksbase->first;
411  while (track && tot < 3) {
412  if (track->flag & TRACK_HAS_BUNDLE && TRACK_VIEW_SELECTED(sc, track)) {
413  mul_v3_m4v3(vec[tot], mat, track->bundle_pos);
414  if (tot == 0 || track == act_track) {
415  copy_v3_v3(orig, vec[tot]);
416  }
417  else {
418  axis_track = track;
419  }
420  tot++;
421  }
422  track = track->next;
423  }
424 
425  sub_v3_v3(vec[1], vec[0]);
426  sub_v3_v3(vec[2], vec[0]);
427 
428  /* Construct ortho-normal basis. */
429  unit_m4(mat);
430  if (plane == 0) { /* floor */
431  cross_v3_v3v3(mat[0], vec[1], vec[2]);
432  copy_v3_v3(mat[1], vec[1]);
433  cross_v3_v3v3(mat[2], mat[0], mat[1]);
434  }
435  else if (plane == 1) { /* wall */
436  cross_v3_v3v3(mat[2], vec[1], vec[2]);
437  copy_v3_v3(mat[1], vec[1]);
438  cross_v3_v3v3(mat[0], mat[1], mat[2]);
439  }
440 
441  normalize_v3(mat[0]);
442  normalize_v3(mat[1]);
443  normalize_v3(mat[2]);
444 
445  /* Move to origin point. */
446  mat[3][0] = orig[0];
447  mat[3][1] = orig[1];
448  mat[3][2] = orig[2];
449 
450  if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
451  invert_m4(mat);
452 
453  BKE_object_to_mat4(object, obmat);
454  mul_m4_m4m4(mat, mat, obmat);
455  mul_m4_m4m4(newmat, rot, mat);
456  BKE_object_apply_mat4(object, newmat, 0, 0);
457 
458  /* Make camera have positive z-coordinate. */
459  if (object->loc[2] < 0) {
460  invert_m4(rot);
461  mul_m4_m4m4(newmat, rot, mat);
462  BKE_object_apply_mat4(object, newmat, 0, 0);
463  }
464  }
465  else {
466  BKE_object_apply_mat4(object, mat, 0, 0);
467  }
468 
470  Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
471  Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
472  BKE_object_transform_copy(object_eval, object);
473  BKE_object_where_is_calc(depsgraph, scene_eval, object_eval);
474  BKE_object_transform_copy(object, object_eval);
475 
476  set_axis(scene, object, clip, tracking_object, axis_track, 'X');
477 
478  DEG_id_tag_update(&clip->id, 0);
480 
483 
484  return OPERATOR_FINISHED;
485 }
486 
488 {
489  static const EnumPropertyItem plane_items[] = {
490  {0, "FLOOR", 0, "Floor", "Set floor plane"},
491  {1, "WALL", 0, "Wall", "Set wall plane"},
492  {0, NULL, 0, NULL, NULL},
493  };
494 
495  /* identifiers */
496  ot->name = "Set Plane";
497  ot->description =
498  "Set plane based on 3 selected bundles by moving camera "
499  "(or its parent if present) in 3D space";
500  ot->idname = "CLIP_OT_set_plane";
501 
502  /* api callbacks */
505 
506  /* flags */
508 
509  /* properties */
510  RNA_def_enum(ot->srna, "plane", plane_items, 0, "Plane", "Plane to be used for orientation");
511 }
512 
513 /********************** set axis operator *********************/
514 
516 {
518  MovieClip *clip = ED_space_clip_get_clip(sc);
519  MovieTracking *tracking = &clip->tracking;
520  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
522  Object *object;
523  int axis = RNA_enum_get(op->ptr, "axis");
524 
525  if (count_selected_bundles(C) != 1) {
526  BKE_report(
527  op->reports, RPT_ERROR, "Single track with bundle should be selected to define axis");
528  return OPERATOR_CANCELLED;
529  }
530 
531  object = get_orientation_object(C);
532  if (object == NULL) {
533  BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
534  return OPERATOR_CANCELLED;
535  }
536 
537  ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
538  MovieTrackingTrack *track = tracksbase->first;
539  while (track) {
540  if (TRACK_VIEW_SELECTED(sc, track) && (track->flag & TRACK_HAS_BUNDLE)) {
541  break;
542  }
543  track = track->next;
544  }
545 
546  set_axis(scene, object, clip, tracking_object, track, axis == 0 ? 'X' : 'Y');
547 
548  DEG_id_tag_update(&clip->id, 0);
550 
553 
554  return OPERATOR_FINISHED;
555 }
556 
558 {
559  static const EnumPropertyItem axis_actions[] = {
560  {0, "X", 0, "X", "Align bundle align X axis"},
561  {1, "Y", 0, "Y", "Align bundle align Y axis"},
562  {0, NULL, 0, NULL, NULL},
563  };
564 
565  /* identifiers */
566  ot->name = "Set Axis";
567  ot->description =
568  "Set direction of scene axis rotating camera "
569  "(or its parent if present) and assume selected track "
570  "lies on real axis, joining it with the origin";
571  ot->idname = "CLIP_OT_set_axis";
572 
573  /* api callbacks */
574  ot->exec = set_axis_exec;
576 
577  /* flags */
579 
580  /* properties */
581  RNA_def_enum(ot->srna, "axis", axis_actions, 0, "Axis", "Axis to use to align bundle along");
582 }
583 
584 /********************** set scale operator *********************/
585 
586 static int do_set_scale(bContext *C, wmOperator *op, bool scale_solution, bool apply_scale)
587 {
589  MovieClip *clip = ED_space_clip_get_clip(sc);
590  MovieTracking *tracking = &clip->tracking;
591  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
592  MovieTrackingTrack *track;
594  Object *object = NULL;
596  ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
597  int tot = 0;
598  float vec[2][3], mat[4][4], scale;
599  float dist = RNA_float_get(op->ptr, "distance");
600 
601  if (count_selected_bundles(C) != 2) {
602  BKE_report(op->reports, RPT_ERROR, "Two tracks with bundles should be selected to set scale");
603  return OPERATOR_CANCELLED;
604  }
605 
606  if (!scale_solution && !apply_scale) {
607  object = get_orientation_object(C);
608  if (object == NULL) {
609  BKE_report(op->reports, RPT_ERROR, "No object to apply orientation on");
610  return OPERATOR_CANCELLED;
611  }
612  }
613 
615 
616  track = tracksbase->first;
617  while (track) {
618  if (TRACK_VIEW_SELECTED(sc, track)) {
619  mul_v3_m4v3(vec[tot], mat, track->bundle_pos);
620  tot++;
621  }
622  track = track->next;
623  }
624 
625  sub_v3_v3(vec[0], vec[1]);
626 
627  if (len_v3(vec[0]) > 1e-5f) {
628  scale = dist / len_v3(vec[0]);
629  if (apply_scale) {
630  /* Apply scale on reconstructed scene itself. */
632  tracking);
633  MovieReconstructedCamera *reconstructed_cameras;
634  int i;
635 
636  for (track = tracksbase->first; track; track = track->next) {
637  mul_v3_fl(track->bundle_pos, scale);
638  }
639 
640  reconstructed_cameras = reconstruction->cameras;
641  for (i = 0; i < reconstruction->camnr; i++) {
642  mul_v3_fl(reconstructed_cameras[i].mat[3], scale);
643  }
644 
647  }
648  else {
649  if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
650  mul_v3_fl(object->scale, scale);
651  mul_v3_fl(object->loc, scale);
652  }
653  else if (!scale_solution) {
654  Object *solver_camera = object_solver_camera(scene, object);
655 
656  object->scale[0] = object->scale[1] = object->scale[2] = 1.0f / scale;
657 
658  if (solver_camera) {
659  object->scale[0] /= solver_camera->scale[0];
660  object->scale[1] /= solver_camera->scale[1];
661  object->scale[2] /= solver_camera->scale[2];
662  }
663  }
664  else {
665  tracking_object->scale = scale;
666  }
667 
668  DEG_id_tag_update(&clip->id, 0);
669 
670  if (object) {
672  }
673 
676  }
677  }
678 
679  return OPERATOR_FINISHED;
680 }
681 
683 {
684  return do_set_scale(C, op, false, false);
685 }
686 
687 static int set_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
688 {
690  MovieClip *clip = ED_space_clip_get_clip(sc);
691 
692  if (!RNA_struct_property_is_set(op->ptr, "distance")) {
693  RNA_float_set(op->ptr, "distance", clip->tracking.settings.dist);
694  }
695 
696  return set_scale_exec(C, op);
697 }
698 
700 {
701  /* identifiers */
702  ot->name = "Set Scale";
703  ot->description = "Set scale of scene by scaling camera (or its parent if present)";
704  ot->idname = "CLIP_OT_set_scale";
705 
706  /* api callbacks */
710 
711  /* flags */
713 
714  /* properties */
716  "distance",
717  0.0f,
718  -FLT_MAX,
719  FLT_MAX,
720  "Distance",
721  "Distance between selected tracks",
722  -100.0f,
723  100.0f);
724 }
725 
726 /********************** set solution scale operator *********************/
727 
729 {
731  if (sc != NULL) {
732  MovieClip *clip = ED_space_clip_get_clip(sc);
733  if (clip != NULL) {
734  MovieTracking *tracking = &clip->tracking;
735  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
736  return (tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0;
737  }
738  }
739  return false;
740 }
741 
743 {
744  return do_set_scale(C, op, true, false);
745 }
746 
748 {
750  MovieClip *clip = ED_space_clip_get_clip(sc);
751 
752  if (!RNA_struct_property_is_set(op->ptr, "distance")) {
753  RNA_float_set(op->ptr, "distance", clip->tracking.settings.object_distance);
754  }
755 
756  return set_solution_scale_exec(C, op);
757 }
758 
760 {
761  /* identifiers */
762  ot->name = "Set Solution Scale";
763  ot->description =
764  "Set object solution scale using distance between "
765  "two selected tracks";
766  ot->idname = "CLIP_OT_set_solution_scale";
767 
768  /* api callbacks */
772 
773  /* flags */
775 
776  /* properties */
778  "distance",
779  0.0f,
780  -FLT_MAX,
781  FLT_MAX,
782  "Distance",
783  "Distance between selected tracks",
784  -100.0f,
785  100.0f);
786 }
787 
788 /********************** apply solution scale operator *********************/
789 
791 {
793  if (sc != NULL) {
794  MovieClip *clip = ED_space_clip_get_clip(sc);
795  if (clip != NULL) {
796  MovieTracking *tracking = &clip->tracking;
797  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
798  return (tracking_object->flag & TRACKING_OBJECT_CAMERA) != 0;
799  }
800  }
801  return 0;
802 }
803 
805 {
806  return do_set_scale(C, op, false, true);
807 }
808 
810 {
812  MovieClip *clip = ED_space_clip_get_clip(sc);
813  if (!RNA_struct_property_is_set(op->ptr, "distance")) {
814  RNA_float_set(op->ptr, "distance", clip->tracking.settings.dist);
815  }
816  return apply_solution_scale_exec(C, op);
817 }
818 
820 {
821  /* identifiers */
822  ot->name = "Apply Solution Scale";
823  ot->description =
824  "Apply scale on solution itself to make distance between "
825  "selected tracks equals to desired";
826  ot->idname = "CLIP_OT_apply_solution_scale";
827 
828  /* api callbacks */
832 
833  /* flags */
835 
836  /* properties */
838  "distance",
839  0.0f,
840  -FLT_MAX,
841  FLT_MAX,
842  "Distance",
843  "Distance between selected tracks",
844  -100.0f,
845  100.0f);
846 }
#define FOREACH_SCENE_OBJECT_END
#define FOREACH_SCENE_OBJECT_BEGIN(scene, _instance)
const bConstraintTypeInfo * BKE_constraint_typeinfo_get(struct bConstraint *con)
Definition: constraint.c:5506
struct Scene * CTX_data_scene(const bContext *C)
Definition: context.c:1090
struct SpaceClip * CTX_wm_space_clip(const bContext *C)
Definition: context.c:923
struct ViewLayer * CTX_data_view_layer(const bContext *C)
Definition: context.c:1100
struct Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C)
Definition: context.c:1528
General operations, lookup, etc. for blender objects.
struct MovieClip * BKE_object_movieclip_get(struct Scene *scene, struct Object *ob, bool use_default)
Definition: object.cc:5042
void BKE_object_where_is_calc(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob)
Definition: object.cc:3495
void BKE_object_transform_copy(struct Object *ob_tar, const struct Object *ob_src)
void BKE_object_where_is_calc_mat4(struct Object *ob, float r_obmat[4][4])
Definition: object.cc:3478
void BKE_object_rot_to_mat3(const struct Object *ob, float r_mat[3][3], bool use_drot)
void BKE_object_to_mat4(struct Object *ob, float r_mat[4][4])
Definition: object.cc:3082
void BKE_object_apply_mat4(struct Object *ob, const float mat[4][4], bool use_compat, bool use_parent)
Definition: object.cc:3575
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition: report.c:83
void BKE_tracking_get_camera_object_matrix(struct Object *camera_object, float mat[4][4])
Definition: tracking.c:375
struct ListBase * BKE_tracking_get_active_tracks(struct MovieTracking *tracking)
Definition: tracking.c:346
struct MovieTrackingTrack * BKE_tracking_track_get_active(struct MovieTracking *tracking)
Definition: tracking.c:1089
struct MovieTrackingReconstruction * BKE_tracking_get_active_reconstruction(struct MovieTracking *tracking)
Definition: tracking.c:368
#define TRACK_VIEW_SELECTED(sc, track)
Definition: BKE_tracking.h:831
struct ListBase * BKE_tracking_object_get_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object)
Definition: tracking.c:2112
struct MovieTrackingObject * BKE_tracking_object_get_active(struct MovieTracking *tracking)
Definition: tracking.c:2092
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
Definition: math_matrix.c:259
bool invert_m4(float R[4][4])
Definition: math_matrix.c:1206
void mul_m4_m4m3(float R[4][4], const float A[4][4], const float B[3][3])
Definition: math_matrix.c:434
void unit_m4(float m[4][4])
Definition: rct.c:1090
bool invert_m4_m4(float R[4][4], const float A[4][4])
Definition: math_matrix.c:1287
#define mul_m4_series(...)
void mul_v3_m4v3(float r[3], const float M[4][4], const float v[3])
Definition: math_matrix.c:739
bool invert_m3(float R[3][3])
Definition: math_matrix.c:1171
MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
MINLINE float normalize_v3(float r[3])
MINLINE void sub_v3_v3(float r[3], const float a[3])
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void zero_v3(float r[3])
MINLINE void add_v3_v3(float r[3], const float a[3])
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
#define UNUSED(x)
struct Depsgraph Depsgraph
Definition: DEG_depsgraph.h:35
void DEG_id_tag_update(struct ID *id, int flag)
struct Object * DEG_get_evaluated_object(const struct Depsgraph *depsgraph, struct Object *object)
struct Scene * DEG_get_evaluated_scene(const struct Depsgraph *graph)
@ ID_RECALC_TRANSFORM
Definition: DNA_ID.h:771
@ CONSTRAINT_TYPE_OBJECTSOLVER
Object is a sort of wrapper for general info.
@ OB_CAMERA
#define OBACT(_view_layer)
@ TRACKING_OBJECT_CAMERA
@ TRACK_HAS_BUNDLE
@ OPERATOR_CANCELLED
@ OPERATOR_FINISHED
struct MovieClip * ED_space_clip_get_clip(struct SpaceClip *sc)
Definition: clip_editor.c:570
Read Guarded memory(de)allocation.
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between camera
#define C
Definition: RandGen.cpp:25
@ OPTYPE_UNDO
Definition: WM_types.h:148
@ OPTYPE_REGISTER
Definition: WM_types.h:146
#define NA_EVALUATED
Definition: WM_types.h:524
#define NC_MOVIECLIP
Definition: WM_types.h:347
#define ND_TRANSFORM
Definition: WM_types.h:405
#define NC_OBJECT
Definition: WM_types.h:329
return(oflags[bm->toolflag_index].f &oflag) !=0
Scene scene
const Depsgraph * depsgraph
#define rot(x, k)
const ProjectiveReconstruction & reconstruction
Definition: intersect.cc:198
#define fabsf(x)
Definition: metal/compat.h:219
float RNA_float_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4957
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
Definition: rna_access.c:4968
bool RNA_struct_property_is_set(PointerRNA *ptr, const char *identifier)
Definition: rna_access.c:5301
int RNA_enum_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:5004
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, float default_value, float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
Definition: rna_define.c:3836
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, bool default_value, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3493
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3783
void * first
Definition: DNA_listBase.h:31
struct MovieTracking tracking
struct MovieTrackingTrack * next
MovieTrackingSettings settings
ListBase constraints
float loc[3]
float scale[3]
struct Object * parent
struct Object * camera
int(* invoke)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:919
const char * name
Definition: WM_types.h:888
const char * idname
Definition: WM_types.h:890
bool(* poll)(struct bContext *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:943
struct StructRNA * srna
Definition: WM_types.h:969
const char * description
Definition: WM_types.h:893
int(* exec)(struct bContext *, struct wmOperator *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:903
struct ReportList * reports
struct PointerRNA * ptr
void CLIP_OT_set_origin(wmOperatorType *ot)
static void set_axis(Scene *scene, Object *ob, MovieClip *clip, MovieTrackingObject *tracking_object, MovieTrackingTrack *track, char axis)
void CLIP_OT_apply_solution_scale(wmOperatorType *ot)
static bool set_orientation_poll(bContext *C)
static int apply_solution_scale_exec(bContext *C, wmOperator *op)
static bool set_solution_scale_poll(bContext *C)
static int apply_solution_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
void CLIP_OT_set_solution_scale(wmOperatorType *ot)
void CLIP_OT_set_axis(wmOperatorType *ot)
static int set_origin_exec(bContext *C, wmOperator *op)
static Object * get_orientation_object(bContext *C)
static int set_scale_exec(bContext *C, wmOperator *op)
static int do_set_scale(bContext *C, wmOperator *op, bool scale_solution, bool apply_scale)
static bool apply_solution_scale_poll(bContext *C)
static int set_solution_scale_exec(bContext *C, wmOperator *op)
void CLIP_OT_set_scale(wmOperatorType *ot)
static Object * object_solver_camera(Scene *scene, Object *ob)
static int set_axis_exec(bContext *C, wmOperator *op)
static int set_plane_exec(bContext *C, wmOperator *op)
static int set_solution_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
static int set_scale_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
static void object_solver_inverted_matrix(Scene *scene, Object *ob, float invmat[4][4])
static Object * get_camera_with_movieclip(Scene *scene, MovieClip *clip)
static int count_selected_bundles(bContext *C)
void CLIP_OT_set_plane(wmOperatorType *ot)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
wmOperatorType * ot
Definition: wm_files.c:3479