Blender V5.3
clip_graph_draw.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
10#include "DNA_scene_types.h"
11#include "DNA_screen_types.h"
12
13#include "BLI_utildefines.hh"
14
15#include "BKE_movieclip.hh"
16#include "BKE_tracking.hh"
17
18#include "ED_anim_api.hh"
19#include "ED_clip.hh"
20
21#include "GPU_immediate.hh"
22#include "GPU_immediate_util.hh"
23#include "GPU_matrix.hh"
24#include "GPU_state.hh"
25
26#include "UI_resources.hh"
27#include "UI_view2d.hh"
28
29#include "clip_intern.hh" /* own include */
30
31namespace blender {
32
40
41static void tracking_segment_point_cb(void *userdata,
42 MovieTrackingTrack * /*track*/,
43 MovieTrackingMarker * /*marker*/,
44 eClipCurveValueSource value_source,
45 int scene_framenr,
46 float val)
47{
48 TrackMotionCurveUserData *data = static_cast<TrackMotionCurveUserData *>(userdata);
49
50 if (!clip_graph_value_visible(data->sc, value_source)) {
51 return;
52 }
53
54 immVertex2f(data->pos, scene_framenr, val);
55}
56
57static void tracking_segment_start_cb(void *userdata,
58 MovieTrackingTrack *track,
59 eClipCurveValueSource value_source,
60 bool is_point)
61{
62 TrackMotionCurveUserData *data = static_cast<TrackMotionCurveUserData *>(userdata);
63 SpaceClip *sc = data->sc;
64 float col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
65
66 if (!clip_graph_value_visible(sc, value_source)) {
67 return;
68 }
69
70 switch (value_source) {
73 break;
76 break;
79 break;
80 }
81
82 if (track == data->act_track) {
83 col[3] = 1.0f;
84 GPU_line_width(2.0f);
85 }
86 else {
87 col[3] = 0.5f;
88 GPU_line_width(1.0f);
89 }
90
91 if (is_point) {
93 immUniform1f("size", 3.0f);
94 }
95 else {
97 }
99
100 if (is_point) {
102 }
103 else {
104 /* Graph can be composed of smaller segments, if any marker is disabled */
106 }
107}
108
109static void tracking_segment_end_cb(void *userdata, eClipCurveValueSource value_source)
110{
111 TrackMotionCurveUserData *data = static_cast<TrackMotionCurveUserData *>(userdata);
112 SpaceClip *sc = data->sc;
113 if (!clip_graph_value_visible(sc, value_source)) {
114 return;
115 }
116 immEnd();
118}
119
120static void tracking_segment_knot_cb(void *userdata,
121 MovieTrackingTrack *track,
122 MovieTrackingMarker *marker,
123 eClipCurveValueSource value_source,
124 int scene_framenr,
125 float val)
126{
127 TrackMotionCurveUserData *data = static_cast<TrackMotionCurveUserData *>(userdata);
128
129 if (track != data->act_track) {
130 return;
131 }
133 return;
134 }
135
136 const TrackingMarkerFlag sel_flag = value_source == CLIP_VALUE_SOURCE_SPEED_X ?
139 const bool sel = (marker->flag & sel_flag) != 0;
140
141 if (sel == data->sel) {
142 GPU_line_width(1.0f);
145
147 GPU_matrix_translate_2f(scene_framenr, val);
148 GPU_matrix_scale_2f(1.0f / data->xscale * data->hsize, 1.0f / data->yscale * data->hsize);
149
150 imm_draw_circle_wire_2d(data->pos, 0, 0, 0.7, 8);
151
154 }
155}
156
158{
160 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
161 MovieTrackingTrack *active_track = tracking_object->active_track;
162 const bool draw_knots = (sc->flag & SC_SHOW_GRAPH_TRACKS_MOTION) != 0;
163
164 int width, height;
165 BKE_movieclip_get_size(clip, &sc->user, &width, &height);
166 if (!width || !height) {
167 return;
168 }
169
171 userdata.sc = sc;
173 userdata.sel = false;
174 userdata.act_track = active_track;
175 userdata.pos = pos;
176
177 /* Non-selected knot handles. */
178 if (draw_knots) {
179 ui::view2d_scale_get(v2d, &userdata.xscale, &userdata.yscale);
181 (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,
182 (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,
183 &userdata,
185 nullptr,
186 nullptr);
187 }
188
189 /* Draw graph lines. */
192 (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,
193 (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,
194 &userdata,
199
200 /* Selected knot handles on top of curves. */
201 if (draw_knots) {
202 userdata.sel = true;
204 (sc->flag & SC_SHOW_GRAPH_SEL_ONLY) != 0,
205 (sc->flag & SC_SHOW_GRAPH_HIDDEN) != 0,
206 &userdata,
208 nullptr,
209 nullptr);
210 }
211}
212
213static void draw_frame_curves(SpaceClip *sc, uint pos)
214{
216 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
217 const MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
218
219 int previous_frame;
220 float previous_error;
221 bool have_previous_point = false;
222
223 /* Indicates whether immBegin() was called. */
224 bool is_lines_segment_open = false;
225
226 GPU_line_width(1.0f);
228 immUniformColor4f(0.0f, 0.0f, 1.0f, 1.0f);
229
230 for (int i = 0; i < reconstruction->camnr; i++) {
231 MovieReconstructedCamera *camera = &reconstruction->cameras[i];
232
233 const int current_frame = BKE_movieclip_remap_clip_to_scene_frame(clip, camera->framenr);
234 const float current_error = camera->error;
235
236 if (have_previous_point && current_frame != previous_frame + 1) {
237 if (is_lines_segment_open) {
238 immEnd();
239 is_lines_segment_open = false;
240 }
241 have_previous_point = false;
242 }
243
244 if (have_previous_point) {
245 if (!is_lines_segment_open) {
246 immBeginAtMost(GPU_PRIM_LINE_STRIP, reconstruction->camnr);
247 is_lines_segment_open = true;
248
249 immVertex2f(pos, previous_frame, previous_error);
250 }
251 immVertex2f(pos, current_frame, current_error);
252 }
253
254 previous_frame = current_frame;
255 previous_error = current_error;
256 have_previous_point = true;
257 }
258
259 if (is_lines_segment_open) {
260 immEnd();
261 }
263}
264
265void clip_draw_graph(SpaceClip *sc, ARegion *region, Scene *scene)
266{
268 View2D *v2d = &region->v2d;
269
270 /* grid */
271 ui::view2d_draw_lines_x(v2d, scene, false, true, true, 10);
272 ui::view2d_draw_lines_y(v2d, true, 10);
273
274 if (clip) {
275 uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", gpu::VertAttrType::SFLOAT_32_32);
276
279 }
280
281 if (sc->flag & SC_SHOW_GRAPH_FRAMES) {
282 draw_frame_curves(sc, pos);
283 }
284 }
285
286 /* Frame and preview range. */
288 ANIM_draw_framerange(scene, v2d);
289 ANIM_draw_previewrange(scene, v2d, 0);
290}
291
292} // namespace blender
#define ELEM(...)
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
void get_color_4fv(int colorid, float col[4])
float get_value_f(int colorid)
void view2d_view_ortho(const View2D *v2d)
Definition view2d.cc:1080
void view2d_draw_lines_x(const View2D *v2d, const Scene *scene, bool display_seconds, bool show_fractions, bool draw_minor_lines, int base)
void view2d_draw_lines_y(const View2D *v2d, bool show_fractions, int base)
void view2d_scale_get(const View2D *v2d, float *r_x, float *r_y)
Definition view2d.cc:1893
BMesh Iterators.
void ANIM_draw_framerange(Scene *scene, View2D *v2d)
Definition anim_draw.cc:176
void clip_draw_graph(SpaceClip *sc, ARegion *region, Scene *scene)
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
void immEnd()
unsigned int uint
Definition BKE_text.h:55
void immBeginAtMost(GPUPrimType, uint max_vertex_len)
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
GPUVertFormat * immVertexFormat()
@ GPU_PRIM_LINE_STRIP
static void draw_tracks_motion_and_error_curves(View2D *v2d, SpaceClip *sc, uint pos)
@ TH_HANDLE_VERTEX_SELECT
@ TH_HANDLE_VERTEX_SIZE
void immUniformColor4fv(const float rgba[4])
bool clip_graph_value_visible(SpaceClip *sc, eClipCurveValueSource value_source)
Definition clip_utils.cc:41
static void tracking_segment_knot_cb(void *userdata, MovieTrackingTrack *track, MovieTrackingMarker *marker, eClipCurveValueSource value_source, int scene_framenr, float val)
void immUnbindProgram()
eClipCurveValueSource
@ CLIP_VALUE_SOURCE_SPEED_Y
@ CLIP_VALUE_SOURCE_SPEED_X
@ CLIP_VALUE_SOURCE_REPROJECTION_ERROR
void GPU_line_width(float width)
Definition gpu_state.cc:151
void GPU_matrix_scale_2f(float x, float y)
@ GPU_BLEND_NONE
Definition GPU_state.hh:88
@ GPU_BLEND_ALPHA
Definition GPU_state.hh:90
void immBindBuiltinProgram(GPUBuiltinShader shader_id)
void imm_draw_circle_wire_2d(uint shdr_pos, float x, float y, float radius, int nsegments)
void immUniformThemeColor(int color_id)
@ SC_SHOW_GRAPH_TRACKS_MOTION
@ SC_SHOW_GRAPH_TRACKS_ERROR
void immUniform1f(const char *name, float x)
void immVertex2f(uint attr_id, float x, float y)
static void tracking_segment_end_cb(void *userdata, eClipCurveValueSource value_source)
BMesh const char void * data
@ GPU_SHADER_3D_POINT_UNIFORM_COLOR
void immUniformColor4f(float r, float g, float b, float a)
void ANIM_draw_previewrange(const Scene *scene, View2D *v2d, int end_frame_width)
Definition anim_draw.cc:88
void GPU_matrix_translate_2f(float x, float y)
uint GPU_vertformat_attr_add(GPUVertFormat *format, StringRef name, gpu::VertAttrType type)
void clip_graph_tracking_values_iterate(SpaceClip *sc, bool selected_only, bool include_hidden, void *userdata, ClipTrackValueCallback func, ClipTrackValueSegmentStartCallback segment_start, ClipTrackValueSegmentEndCallback segment_end)
static void tracking_segment_start_cb(void *userdata, MovieTrackingTrack *track, eClipCurveValueSource value_source, bool is_point)
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
static void draw_frame_curves(SpaceClip *sc, uint pos)
static void tracking_segment_point_cb(void *userdata, MovieTrackingTrack *, MovieTrackingMarker *, eClipCurveValueSource value_source, int scene_framenr, float val)
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
void GPU_blend(GPUBlend blend)
Definition gpu_state.cc:44
void GPU_matrix_pop()
void GPU_matrix_push()
struct MovieTracking tracking
MovieTrackingReconstruction reconstruction
MovieTrackingTrack * active_track
struct MovieReconstructedCamera * cameras
eSpaceClip_Flag flag
struct MovieClipUser user