Blender V5.3
clip_graph_ops.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10
11#include "DNA_scene_types.h"
12
13#include "BLI_math_geom_c.hh"
14#include "BLI_math_vector_c.hh"
15#include "BLI_rect.hh"
16#include "BLI_utildefines.hh"
17
18#include "BLT_translation.hh"
19
20#include "BKE_context.hh"
21#include "BKE_tracking.hh"
22
23#include "DEG_depsgraph.hh"
24
25#include "UI_interface_icons.hh"
26
27#include "WM_api.hh"
28#include "WM_types.hh"
29
30#include "ED_clip.hh"
31#include "ED_screen.hh"
32#include "ED_select_utils.hh"
33
34#include "RNA_access.hh"
35#include "RNA_define.hh"
36
37#include "UI_view2d.hh"
38
39#include "clip_intern.hh" /* own include */
40
41namespace blender {
42
43/******************** common graph-editing utilities ********************/
44
46{
49
50 return sc->view == SC_VIEW_GRAPH;
51 }
52
53 return false;
54}
55
57{
60
62 }
63 return false;
64}
65
67 int action;
68};
69
70static void toggle_selection_cb(void *userdata, MovieTrackingMarker *marker)
71{
72 SelectUserData *data = static_cast<SelectUserData *>(userdata);
73
74 switch (data->action) {
75 case SEL_SELECT:
76 marker->flag |= MARKER_GRAPH_SEL;
77 break;
78 case SEL_DESELECT:
79 marker->flag &= ~MARKER_GRAPH_SEL;
80 break;
81 case SEL_INVERT:
82 marker->flag ^= MARKER_GRAPH_SEL;
83 break;
84 }
85}
86
87/******************** mouse select operator ********************/
88
92 bool has_prev; /* if there's valid coordinate of previous point of curve segment */
93
94 float min_dist_sq; /* minimal distance between mouse and currently found entity */
95 float mouse_co[2]; /* mouse coordinate */
96 float prev_co[2]; /* coordinate of previous point of segment */
97 float min_co[2]; /* coordinate of entity with minimal distance */
98
99 MovieTrackingTrack *track; /* nearest found track */
100 MovieTrackingMarker *marker; /* nearest found marker */
101};
102
103static void find_nearest_tracking_segment_cb(void *userdata,
104 MovieTrackingTrack *track,
105 MovieTrackingMarker * /*marker*/,
106 eClipCurveValueSource value_source,
107 int scene_framenr,
108 float val)
109{
110 MouseSelectUserData *data = static_cast<MouseSelectUserData *>(userdata);
111 const float co[2] = {float(scene_framenr), val};
112
113 if (!clip_graph_value_visible(data->sc, value_source)) {
114 return;
115 }
116
117 if (data->has_prev) {
118 float dist_sq = dist_squared_to_line_segment_v2(data->mouse_co, data->prev_co, co);
119
120 if (data->track == nullptr || dist_sq < data->min_dist_sq) {
121 data->track = track;
122 data->min_dist_sq = dist_sq;
123 data->value_source = value_source;
124 copy_v2_v2(data->min_co, co);
125 }
126 }
127
128 data->has_prev = true;
129 copy_v2_v2(data->prev_co, co);
130}
131
132static void find_nearest_tracking_segment_end_cb(void *userdata,
133 eClipCurveValueSource /*source_value*/)
134{
135 MouseSelectUserData *data = static_cast<MouseSelectUserData *>(userdata);
136
137 data->has_prev = false;
138}
139
140static void find_nearest_tracking_knot_cb(void *userdata,
141 MovieTrackingTrack *track,
142 MovieTrackingMarker *marker,
143 eClipCurveValueSource value_source,
144 int scene_framenr,
145 float val)
146{
147 MouseSelectUserData *data = static_cast<MouseSelectUserData *>(userdata);
148 const float mdiff[2] = {scene_framenr - data->mouse_co[0], val - data->mouse_co[1]};
149 float dist_sq = len_squared_v2(mdiff);
150
151 if (!clip_graph_value_visible(data->sc, value_source)) {
152 return;
153 }
154
155 if (data->marker == nullptr || dist_sq < data->min_dist_sq) {
156 const float co[2] = {float(scene_framenr), val};
157
158 data->track = track;
159 data->marker = marker;
160 data->min_dist_sq = dist_sq;
161 data->value_source = value_source;
162 copy_v2_v2(data->min_co, co);
163 }
164}
165
166static void mouse_select_init_data(bContext *C, MouseSelectUserData *userdata, const float co[2])
167{
169 memset(userdata, 0, sizeof(MouseSelectUserData));
170 userdata->sc = sc;
171 userdata->min_dist_sq = FLT_MAX;
172 copy_v2_v2(userdata->mouse_co, co);
173}
174
175static bool mouse_select_knot(bContext *C, const float co[2], bool extend)
176{
179 ARegion *region = CTX_wm_region(C);
180 View2D *v2d = &region->v2d;
181 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
182 MovieTrackingTrack *active_track = tracking_object->active_track;
183 static const int delta = 6;
184
185 if (active_track) {
186 MouseSelectUserData userdata;
187
188 mouse_select_init_data(C, &userdata, co);
190 sc, active_track, &userdata, find_nearest_tracking_knot_cb, nullptr, nullptr);
191
192 if (userdata.marker) {
193 int x1, y1, x2, y2;
194
195 if (ui::view2d_view_to_region_clip(v2d, co[0], co[1], &x1, &y1) &&
196 ui::view2d_view_to_region_clip(v2d, userdata.min_co[0], userdata.min_co[1], &x2, &y2) &&
197 (abs(x2 - x1) <= delta && abs(y2 - y1) <= delta))
198 {
199 if (!extend) {
200 SelectUserData selectdata = {SEL_DESELECT};
201
203 (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,
204 (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,
205 &selectdata,
207 }
208
209 if (userdata.value_source == CLIP_VALUE_SOURCE_SPEED_X) {
210 if (extend && (userdata.marker->flag & MARKER_GRAPH_SEL_X) != 0) {
211 userdata.marker->flag &= ~MARKER_GRAPH_SEL_X;
212 }
213 else {
214 userdata.marker->flag |= MARKER_GRAPH_SEL_X;
215 }
216 }
217 else if (userdata.value_source == CLIP_VALUE_SOURCE_SPEED_Y) {
218 if (extend && (userdata.marker->flag & MARKER_GRAPH_SEL_Y) != 0) {
219 userdata.marker->flag &= ~MARKER_GRAPH_SEL_Y;
220 }
221 else {
222 userdata.marker->flag |= MARKER_GRAPH_SEL_Y;
223 }
224 }
225
226 return true;
227 }
228 }
229 }
230
231 return false;
232}
233
234static bool mouse_select_curve(bContext *C, const float co[2], bool extend)
235{
239 MovieTrackingTrack *active_track = tracking_object->active_track;
240 MouseSelectUserData userdata;
241
242 mouse_select_init_data(C, &userdata, co);
244 (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,
245 (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,
246 &userdata,
248 nullptr,
250
251 if (userdata.track) {
252 if (extend) {
253 if (active_track == userdata.track) {
254 /* currently only single curve can be selected
255 * (selected curve represents active track) */
256 active_track = nullptr;
257 }
258 }
259 else if (active_track != userdata.track) {
260 SelectUserData selectdata = {SEL_DESELECT};
261
262 tracking_object->active_track = userdata.track;
263 if ((sc->flag & SC_SHOW_GRAPH_SEL_ONLY) == 0) {
264 BKE_tracking_track_select(&tracking_object->tracks, userdata.track, TRACK_AREA_ALL, false);
265 }
266
267 /* deselect all knots on newly selected curve */
269 (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,
270 (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,
271 &selectdata,
273 }
274
275 return true;
276 }
277
278 return false;
279}
280
281static wmOperatorStatus mouse_select(bContext *C, float co[2], bool extend)
282{
283 bool sel = false;
284
285 /* first try to select knot on selected curves */
286 sel = mouse_select_knot(C, co, extend);
287
288 if (!sel) {
289 /* if there's no close enough knot to mouse position, select nearest curve */
290 sel = mouse_select_curve(C, co, extend);
291 }
292
293 if (sel) {
295 }
296
297 return OPERATOR_FINISHED;
298}
299
301{
302 float co[2];
303 bool extend = RNA_boolean_get(op->ptr, "extend");
304
305 RNA_float_get_array(op->ptr, "location", co);
306
307 return mouse_select(C, co, extend);
308}
309
311{
312 ARegion *region = CTX_wm_region(C);
313 float co[2];
314
315 ui::view2d_region_to_view(&region->v2d, event->mval[0], event->mval[1], &co[0], &co[1]);
316 RNA_float_set_array(op->ptr, "location", co);
317
318 return select_exec(C, op);
319}
320
322{
323 PropertyRNA *prop;
324
325 /* identifiers */
326 ot->name = "Select";
327 ot->description = "Select graph curves";
328 ot->idname = "CLIP_OT_graph_select";
329
330 /* API callbacks. */
331 ot->exec = select_exec;
332 ot->invoke = select_invoke;
334
335 /* flags */
336 ot->flag = OPTYPE_UNDO;
337
338 /* properties */
340 "location",
341 2,
342 nullptr,
343 -FLT_MAX,
344 FLT_MAX,
345 "Location",
346 "Mouse location to select nearest entity",
347 -100.0f,
348 100.0f);
349 prop = RNA_def_boolean(ot->srna,
350 "extend",
351 false,
352 "Extend",
353 "Extend selection rather than clearing the existing selection");
355}
356
357/********************** box select operator *********************/
358
363
364static void box_select_cb(void *userdata,
365 MovieTrackingTrack * /*track*/,
366 MovieTrackingMarker *marker,
367 eClipCurveValueSource value_source,
368 int scene_framenr,
369 float val)
370{
371 BoxSelectuserData *data = static_cast<BoxSelectuserData *>(userdata);
373 return;
374 }
375
376 if (BLI_rctf_isect_pt(&data->rect, scene_framenr, val)) {
378
379 if (value_source == CLIP_VALUE_SOURCE_SPEED_X) {
380 flag = MARKER_GRAPH_SEL_X;
381 }
382 else {
383 flag = MARKER_GRAPH_SEL_Y;
384 }
385
386 if (data->select) {
387 marker->flag |= flag;
388 }
389 else {
390 marker->flag &= ~flag;
391 }
392 data->changed = true;
393 }
394 else if (!data->extend) {
395 marker->flag &= ~MARKER_GRAPH_SEL;
396 }
397}
398
400{
402 ARegion *region = CTX_wm_region(C);
403
405 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
406 MovieTrackingTrack *active_track = tracking_object->active_track;
407 BoxSelectuserData userdata;
408 rctf rect;
409
410 if (active_track == nullptr) {
411 return OPERATOR_CANCELLED;
412 }
413
414 /* get rectangle from operator */
416 ui::view2d_region_to_view_rctf(&region->v2d, &rect, &userdata.rect);
417
418 userdata.changed = false;
419 userdata.select = !RNA_boolean_get(op->ptr, "deselect");
420 userdata.extend = RNA_boolean_get(op->ptr, "extend");
421
423 sc, active_track, &userdata, box_select_cb, nullptr, nullptr);
424
425 if (userdata.changed) {
427
428 return OPERATOR_FINISHED;
429 }
430
431 return OPERATOR_CANCELLED;
432}
433
435{
436 /* identifiers */
437 ot->name = "Box Select";
438 ot->description = "Select curve points using box selection";
439 ot->idname = "CLIP_OT_graph_select_box";
440
441 /* API callbacks. */
446
447 /* flags */
448 ot->flag = OPTYPE_UNDO;
449
450 /* properties */
452}
453
454/********************** select all operator *********************/
455
457{
460 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
461 MovieTrackingTrack *active_track = tracking_object->active_track;
462 int action = RNA_enum_get(op->ptr, "action");
463
464 if (!active_track) {
465 return OPERATOR_CANCELLED;
466 }
467
468 if (action == SEL_TOGGLE) {
469 action = SEL_SELECT;
470
471 for (int a = 0; a < active_track->markersnr; a++) {
472 MovieTrackingMarker *marker = &active_track->markers[a];
473
474 if (marker->flag & MARKER_GRAPH_SEL) {
475 action = SEL_DESELECT;
476 break;
477 }
478 }
479 }
480
481 for (int a = 0; a < active_track->markersnr; a++) {
482 MovieTrackingMarker *marker = &active_track->markers[a];
483
484 switch (action) {
485 case SEL_SELECT:
486 marker->flag |= MARKER_GRAPH_SEL;
487 break;
488 case SEL_DESELECT:
489 marker->flag &= ~MARKER_GRAPH_SEL;
490 break;
491 case SEL_INVERT:
492 marker->flag ^= MARKER_GRAPH_SEL;
493 break;
494 }
495 }
496
498
499 return OPERATOR_FINISHED;
500}
501
503{
504 /* identifiers */
505 ot->name = "(De)select All Markers";
506 ot->description = "Change selection of all markers of active track";
507 ot->idname = "CLIP_OT_graph_select_all_markers";
508
509 /* API callbacks. */
512
513 /* flags */
515
517}
518
519/******************** delete curve operator ********************/
520
522{
525 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
526 MovieTrackingTrack *active_track = tracking_object->active_track;
527
528 if (!active_track) {
529 return OPERATOR_CANCELLED;
530 }
531
532 clip_delete_track(C, clip, active_track);
533
534 return OPERATOR_FINISHED;
535}
536
538{
539 if (RNA_boolean_get(op->ptr, "confirm")) {
541 op,
542 IFACE_("Delete track corresponding to the selected curve?"),
543 nullptr,
544 IFACE_("Delete"),
546 false);
547 }
548 return delete_curve_exec(C, op);
549}
550
552{
553 /* identifiers */
554 ot->name = "Delete Curve";
555 ot->description = "Delete track corresponding to the selected curve";
556 ot->idname = "CLIP_OT_graph_delete_curve";
557
558 /* API callbacks. */
562
563 /* flags */
566}
567
568/******************** delete knot operator ********************/
569
571{
574 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
575 MovieTrackingTrack *active_track = tracking_object->active_track;
576
577 if (active_track) {
578 int a = 0;
579
580 while (a < active_track->markersnr) {
581 MovieTrackingMarker *marker = &active_track->markers[a];
582
583 if (marker->flag & MARKER_GRAPH_SEL) {
584 clip_delete_marker(C, clip, active_track, marker);
585 }
586 else {
587 a++;
588 }
589 }
590 }
591
592 return OPERATOR_FINISHED;
593}
594
596{
597 /* identifiers */
598 ot->name = "Delete Knot";
599 ot->description = "Delete curve knots";
600 ot->idname = "CLIP_OT_graph_delete_knot";
601
602 /* API callbacks. */
605
606 /* flags */
608}
609
610/******************** view all operator ********************/
611
613 float min, max;
614};
615
616static void view_all_cb(void *userdata,
617 MovieTrackingTrack * /*track*/,
618 MovieTrackingMarker * /*marker*/,
619 eClipCurveValueSource /*value_source*/,
620 int /*scene_framenr*/,
621 float val)
622{
623 ViewAllUserData *data = static_cast<ViewAllUserData *>(userdata);
624
625 data->min = std::min(val, data->min);
626 data->max = std::max(val, data->max);
627}
628
630{
631 Scene *scene = CTX_data_scene(C);
632 ARegion *region = CTX_wm_region(C);
634 View2D *v2d = &region->v2d;
635 ViewAllUserData userdata;
636 float extra;
637
638 userdata.max = -FLT_MAX;
639 userdata.min = FLT_MAX;
640
642 (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,
643 (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,
644 &userdata,
646 nullptr,
647 nullptr);
648
649 /* set extents of view to start/end frames */
650 v2d->cur.xmin = float(scene->r.sfra);
651 v2d->cur.xmax = float(scene->r.efra);
652
653 if (userdata.min < userdata.max) {
654 v2d->cur.ymin = userdata.min;
655 v2d->cur.ymax = userdata.max;
656 }
657 else {
658 v2d->cur.ymin = -10;
659 v2d->cur.ymax = 10;
660 }
661
662 /* we need an extra "buffer" factor on either side so that the endpoints are visible */
663 extra = 0.01f * BLI_rctf_size_x(&v2d->cur);
664 v2d->cur.xmin -= extra;
665 v2d->cur.xmax += extra;
666
667 extra = 0.01f * BLI_rctf_size_y(&v2d->cur);
668 v2d->cur.ymin -= extra;
669 v2d->cur.ymax += extra;
670
671 ED_region_tag_redraw(region);
672
673 return OPERATOR_FINISHED;
674}
675
677{
678 /* identifiers */
679 ot->name = "Frame All";
680 ot->description = "View all curves in editor";
681 ot->idname = "CLIP_OT_graph_view_all";
682
683 /* API callbacks. */
684 ot->exec = view_all_exec;
686}
687
688/******************** jump to current frame operator ********************/
689
691{
692 View2D *v2d = &region->v2d;
693 float extra = BLI_rctf_size_x(&v2d->cur) / 2.0f;
694
695 /* set extents of view to start/end frames */
696 v2d->cur.xmin = float(scene->r.cfra) - extra;
697 v2d->cur.xmax = float(scene->r.cfra) + extra;
698}
699
701{
702 Scene *scene = CTX_data_scene(C);
703 ARegion *region = CTX_wm_region(C);
704
706
707 ED_region_tag_redraw(region);
708
709 return OPERATOR_FINISHED;
710}
711
713{
714 /* identifiers */
715 ot->name = "Center Current Frame";
716 ot->description = "Scroll view so current frame would be centered";
717 ot->idname = "CLIP_OT_graph_center_current_frame";
718
719 /* API callbacks. */
722}
723
724/********************** disable markers operator *********************/
725
727{
730 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
731 MovieTrackingTrack *active_track = tracking_object->active_track;
732 const int action = RNA_enum_get(op->ptr, "action");
733
734 if (!active_track || (active_track->flag & TRACK_LOCKED)) {
735 return OPERATOR_CANCELLED;
736 }
737
738 for (int a = 0; a < active_track->markersnr; a++) {
739 MovieTrackingMarker *marker = &active_track->markers[a];
740
741 if (marker->flag & MARKER_GRAPH_SEL) {
742 if (action == 0) {
743 marker->flag |= MARKER_DISABLED;
744 }
745 else if (action == 1) {
746 marker->flag &= ~MARKER_DISABLED;
747 }
748 else {
749 marker->flag ^= MARKER_DISABLED;
750 }
751 }
752 }
753
754 DEG_id_tag_update(&clip->id, 0);
755
757
758 return OPERATOR_FINISHED;
759}
760
762{
763 static const EnumPropertyItem actions_items[] = {
764 {0, "DISABLE", 0, "Disable", "Disable selected markers"},
765 {1, "ENABLE", 0, "Enable", "Enable selected markers"},
766 {2, "TOGGLE", 0, "Toggle", "Toggle disabled flag for selected markers"},
767 {0, nullptr, 0, nullptr, nullptr},
768 };
769
770 /* identifiers */
771 ot->name = "Disable Markers";
772 ot->description = "Disable/enable selected markers";
773 ot->idname = "CLIP_OT_graph_disable_markers";
774
775 /* API callbacks. */
778
779 /* flags */
781
782 /* properties */
783 RNA_def_enum(ot->srna, "action", actions_items, 0, "Action", "Disable action to execute");
784}
785
786} // namespace blender
#define IFACE_(msgid)
#define C
Definition RandGen.cpp:29
#define NC_GEOM
Definition WM_types.hh:406
#define NA_EVALUATED
Definition WM_types.hh:635
#define NC_MOVIECLIP
Definition WM_types.hh:410
#define ND_SELECT
Definition WM_types.hh:551
#define ELEM(...)
#define FLT_MAX
#define abs
void view2d_region_to_view(const View2D *v2d, float x, float y, float *r_view_x, float *r_view_y) ATTR_NONNULL()
Definition view2d.cc:1651
bool view2d_view_to_region_clip(const View2D *v2d, float x, float y, int *r_region_x, int *r_region_y) ATTR_NONNULL()
Definition view2d.cc:1684
void view2d_region_to_view_rctf(const View2D *v2d, const rctf *rect_src, rctf *rect_dst) ATTR_NONNULL()
Definition view2d.cc:1657
BMesh Iterators.
static void find_nearest_tracking_knot_cb(void *userdata, MovieTrackingTrack *track, MovieTrackingMarker *marker, eClipCurveValueSource value_source, int scene_framenr, float val)
static wmOperatorStatus mouse_select(bContext *C, float co[2], bool extend)
void RNA_float_set_array(PointerRNA *ptr, const char *name, const float *values)
void CLIP_OT_graph_select_all_markers(wmOperatorType *ot)
int RNA_enum_get(PointerRNA *ptr, const char *name)
static wmOperatorStatus graph_disable_markers_exec(bContext *C, wmOperator *op)
wmOperatorStatus WM_gesture_box_invoke(bContext *C, wmOperator *op, const wmEvent *event)
static void toggle_selection_cb(void *userdata, MovieTrackingMarker *marker)
static wmOperatorStatus graph_select_all_markers_exec(bContext *C, wmOperator *op)
static bool mouse_select_curve(bContext *C, const float co[2], bool extend)
MINLINE void copy_v2_v2(float r[2], const float a[2])
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
static wmOperatorStatus select_exec(bContext *C, wmOperator *op)
SpaceClip * CTX_wm_space_clip(const bContext *C)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void WM_operator_properties_gesture_box_select(wmOperatorType *ot)
bool clip_graph_value_visible(SpaceClip *sc, eClipCurveValueSource value_source)
Definition clip_utils.cc:41
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
void clip_graph_tracking_values_iterate_track(SpaceClip *sc, MovieTrackingTrack *track, void *userdata, ClipTrackValueCallback func, ClipTrackValueSegmentStartCallback segment_start, ClipTrackValueSegmentEndCallback segment_end)
void WM_operator_properties_select_all(wmOperatorType *ot)
eClipCurveValueSource
@ CLIP_VALUE_SOURCE_SPEED_Y
@ CLIP_VALUE_SOURCE_SPEED_X
void clip_delete_track(bContext *C, MovieClip *clip, MovieTrackingTrack *track)
PropertyRNA * RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, const int len, const float *default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
float dist_squared_to_line_segment_v2(const float p[2], const float l1[2], const float l2[2])
Definition math_geom.cc:307
void CLIP_OT_graph_select(wmOperatorType *ot)
void WM_operator_properties_border_to_rctf(wmOperator *op, rctf *r_rect)
void WM_operator_properties_confirm_or_exec(wmOperatorType *ot)
@ SC_SHOW_GRAPH_TRACKS_MOTION
@ SC_SHOW_GRAPH_TRACKS_ERROR
static wmOperatorStatus delete_knot_exec(bContext *C, wmOperator *)
void DEG_id_tag_update(ID *id, unsigned int flags)
BMesh const char void * data
BLI_INLINE float BLI_rctf_size_y(const struct rctf *rct)
Definition BLI_rect.hh:215
bool BLI_rctf_isect_pt(const struct rctf *rect, float x, float y)
void CLIP_OT_graph_center_current_frame(wmOperatorType *ot)
static wmOperatorStatus box_select_graph_exec(bContext *C, wmOperator *op)
static bool space_clip_graph_poll(bContext *C)
void CLIP_OT_graph_view_all(wmOperatorType *ot)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
wmOperatorStatus WM_operator_confirm_ex(bContext *C, wmOperator *op, const char *title, const char *message, const char *confirm_text, ui::AlertIcon icon, bool cancel_default)
static void find_nearest_tracking_segment_end_cb(void *userdata, eClipCurveValueSource)
void clip_graph_tracking_iterate(SpaceClip *sc, bool selected_only, bool include_hidden, void *userdata, void(*func)(void *userdata, MovieTrackingMarker *marker))
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
static bool clip_graph_knots_poll(bContext *C)
static wmOperatorStatus delete_curve_invoke(bContext *C, wmOperator *op, const wmEvent *)
static void mouse_select_init_data(bContext *C, MouseSelectUserData *userdata, const float co[2])
MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus WM_gesture_box_modal(bContext *C, wmOperator *op, const wmEvent *event)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
void clip_graph_tracking_values_iterate(SpaceClip *sc, bool selected_only, bool include_hidden, void *userdata, ClipTrackValueCallback func, ClipTrackValueSegmentStartCallback segment_start, ClipTrackValueSegmentEndCallback segment_end)
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
BLI_INLINE float BLI_rctf_size_x(const struct rctf *rct)
Definition BLI_rect.hh:211
static wmOperatorStatus view_all_exec(bContext *C, wmOperator *)
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
void clip_delete_marker(bContext *C, MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker)
static void find_nearest_tracking_segment_cb(void *userdata, MovieTrackingTrack *track, MovieTrackingMarker *, eClipCurveValueSource value_source, int scene_framenr, float val)
bool ED_space_clip_tracking_poll(bContext *C)
static void box_select_cb(void *userdata, MovieTrackingTrack *, MovieTrackingMarker *marker, eClipCurveValueSource value_source, int scene_framenr, float val)
Scene * CTX_data_scene(const bContext *C)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
static wmOperatorStatus delete_curve_exec(bContext *C, wmOperator *)
void CLIP_OT_graph_select_box(wmOperatorType *ot)
static wmOperatorStatus select_invoke(bContext *C, wmOperator *op, const wmEvent *event)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
static bool mouse_select_knot(bContext *C, const float co[2], bool extend)
static void view_all_cb(void *userdata, MovieTrackingTrack *, MovieTrackingMarker *, eClipCurveValueSource, int, float val)
void CLIP_OT_graph_delete_curve(wmOperatorType *ot)
ARegion * CTX_wm_region(const bContext *C)
void CLIP_OT_graph_disable_markers(wmOperatorType *ot)
static wmOperatorStatus center_current_frame_exec(bContext *C, wmOperator *)
void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values)
void ED_clip_graph_center_current_frame(Scene *scene, ARegion *region)
void BKE_tracking_track_select(ListBaseT< MovieTrackingTrack > *tracksbase, MovieTrackingTrack *track, eTrackArea area, bool extend)
Definition tracking.cc:1195
void CLIP_OT_graph_delete_knot(wmOperatorType *ot)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
MovieTrackingTrack * track
eClipCurveValueSource value_source
MovieTrackingMarker * marker
struct MovieTracking tracking
ListBaseT< MovieTrackingTrack > tracks
MovieTrackingTrack * active_track
MovieTrackingMarker * markers
struct RenderData r
eSpaceClip_Flag flag
eSpaceClip_View view
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157