25#define DNA_DEPRECATED_ALLOW
89 MovieClip *movie_clip = id_cast<MovieClip *>(
id);
97 std::optional<Library *> ,
102 MovieClip *movie_clip_dst = id_cast<MovieClip *>(id_dst);
103 const MovieClip *movie_clip_src = id_cast<const MovieClip *>(id_src);
108 movie_clip_dst->
anim =
nullptr;
109 movie_clip_dst->
cache =
nullptr;
120 MovieClip *movie_clip = id_cast<MovieClip *>(
id);
130 MovieClip *movie_clip = id_cast<MovieClip *>(
id);
149 MovieClip *movie_clip = id_cast<MovieClip *>(
id);
153 function_callback(
id, &key,
reinterpret_cast<void **
>(&movie_clip->
cache), 0, user_data);
161 MovieClip *movie_clip = id_cast<MovieClip *>(
id);
170 track = tracks->first();
183 ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_base)
196 if (reconstruction->
camnr) {
203 MovieClip *clip = id_cast<MovieClip *>(
id);
206 clip->
anim =
nullptr;
232 ListBaseT<MovieTrackingTrack> *tracksbase)
242 ListBaseT<MovieTrackingPlaneTrack> *plane_tracks_base)
248 reader, &plane_track.point_tracks, &plane_track.point_tracksnr);
249 for (
int i = 0; i < plane_track.point_tracksnr; i++) {
259 MovieClip *clip = id_cast<MovieClip *>(
id);
269 clip->
anim =
nullptr;
295 .id_code = MovieClip::id_type,
301 .name_plural =
N_(
"movieclips"),
304 .asset_type_info =
nullptr,
309 .make_local =
nullptr,
313 .foreach_working_space_color =
nullptr,
314 .foreach_asset_weak_reference =
nullptr,
315 .owner_pointer_get =
nullptr,
319 .blend_read_after_liblink =
nullptr,
321 .blend_read_undo_preserve =
nullptr,
323 .lib_override_apply_post =
nullptr,
365 switch (render_size) {
417 int proxy_render_size,
466 bool use_proxy =
false;
483 colorspace_settings =
nullptr;
526 ImBuf *ibuf =
nullptr;
652 return framenr -
index;
692 return priority_data;
709 MEM_delete(priority_data);
766 if (clip->
cache ==
nullptr) {
843 if (!width || !height) {
872 STRNCPY(filepath_abs, filepath);
907 STRNCPY(filepath_abs, filepath);
954 *width =
float(*width) * 4.0f / 3.0f;
955 *height =
float(*height) * 4.0f / 3.0f;
971 distortion, &clip->
tracking, ibuf, ibuf->
x, ibuf->
y, 0.0f,
true);
1052 int render_flag = 0;
1098 ImBuf *postproc_ibuf =
nullptr;
1113 if (disable_red || disable_green || disable_blue || grayscale) {
1118 return postproc_ibuf;
1173 ImBuf *ibuf =
nullptr;
1175 bool need_postprocess =
false;
1186 need_postprocess =
true;
1195 bool use_sequence =
false;
1217 if (need_postprocess) {
1218 ImBuf *tmpibuf = ibuf;
1237 clip, &user_fallback, flag, postprocess_flag, cache_flag);
1268 ImBuf *reference_ibuf,
1275 float tloc[2], tscale, tangle;
1277 int render_flag = 0;
1290 if (cache->
stabilized.reference_ibuf != reference_ibuf) {
1299 if (cache->
stabilized.postprocess_flag != postprocess_flag) {
1315 clip, clip_framenr, stableibuf->
x, stableibuf->
y, tloc, &tscale, &tangle);
1338 float tloc[2], tscale, tangle;
1361 cache->
stabilized.postprocess_flag = postprocess_flag;
1381 ImBuf *ibuf, *stableibuf =
nullptr;
1427 if (stableibuf != ibuf) {
1460 if (ibuf && ibuf->
x && ibuf->
y) {
1478 r_size[0] =
float(width);
1479 r_size[1] =
float(height);
1497 if (clip->
anim ==
nullptr) {
1517 *r_points =
nullptr;
1549 MEM_delete(clip->
cache);
1550 clip->
cache =
nullptr;
1555 clip->
anim =
nullptr;
1617 scopes->
marker =
nullptr;
1618 scopes->
track =
nullptr;
1624 if (clip ==
nullptr) {
1630 if (track ==
nullptr) {
1638 scopes->
track = track;
1657 undist_marker.
pos[0] *= width;
1658 undist_marker.
pos[1] *= height * aspy;
1661 &clip->
tracking, width, height, undist_marker.
pos, undist_marker.
pos);
1663 undist_marker.
pos[0] /= width;
1664 undist_marker.
pos[1] /= height * aspy;
1668 ibuf, track, &undist_marker,
true,
true);
1682 float pat_min[2], pat_max[2];
1699 int proxy_render_size,
1704 int quality, rectx, recty;
1709 rectx = ibuf->
x * size / 100.0f;
1710 recty = ibuf->
y * size / 100.0f;
1741 const int *build_sizes,
1759 ImBuf *tmpibuf = ibuf;
1766 for (i = 0; i < build_count; i++) {
1772 if (tmpibuf != ibuf) {
1782 const int *build_sizes,
1791 ImBuf *tmpibuf = ibuf;
1798 for (i = 0; i < build_count; i++) {
1802 if (tmpibuf != ibuf) {
1847 ImBuf *ibuf =
nullptr;
1858 bool has_frame =
false;
1925 if (tex ==
nullptr) {
1926 tex = MEM_new<MovieClip_RuntimeGPUTexture>(__func__);
1936 if (clip ==
nullptr) {
1947 if (ibuf ==
nullptr) {
1948 CLOG_ERROR(&
LOG,
"Failed to create GPU texture from Blender movie clip");
1974 const int MOVIECLIP_NUM_GPUTEXTURES = 1;
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
File and directory operations.
#define SNPRINTF(dst, format,...)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_MOVIECLIP
#define CLOG_ERROR(clg_ref,...)
#define FILTER_ID_GD_LEGACY
#define ID_BLEND_PATH_FROM_GLOBAL(_id)
#define ID_BLEND_PATH(_bmain, _id)
#define IMG_SIZE_FALLBACK
Read Blender memory allocation and freeing.
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
void BKE_movieclip_reload(Main *bmain, MovieClip *clip)
size_t BLI_snprintf(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
static bool need_postprocessed_frame(const MovieClipUser *user, int clip_flag, MovieClipPostprocFlag postprocess_flag)
static void movieclip_eval_update_generic(Depsgraph *depsgraph, MovieClip *clip)
char * STRNCPY(char(&dst)[N], const char *src)
void BKE_tracking_copy(MovieTracking *tracking_dst, const MovieTracking *tracking_src, int flag)
static void movie_clip_foreach_id(ID *id, LibraryForeachIDData *data)
void BKE_movieclip_get_size(MovieClip *clip, const MovieClipUser *user, int *r_width, int *r_height)
static void get_proxy_filepath(const MovieClip *clip, int proxy_render_size, bool undistorted, int framenr, char filepath[FILE_MAX])
bool BKE_movieclip_has_frame(MovieClip *clip, const MovieClipUser *user)
static void put_postprocessed_frame_to_cache(MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf, int flag, MovieClipPostprocFlag postprocess_flag)
MINLINE void copy_v3_v3(float r[3], const float a[3])
bool BLI_path_abs(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1
void BKE_ntree_update_tag_id_changed(Main *bmain, ID *id)
bool DEG_is_active(const Depsgraph *depsgraph)
static void movie_clip_foreach_path(ID *id, BPathForeachPathData *bpath_data)
void BLO_read_pointer_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size)
void IMB_cache_get_cache_segments(ImBufCache *cache, int proxy, int render_flags, int *r_totseg, int **r_points)
uint64_t DEG_get_update_count(const Depsgraph *depsgraph)
void MOV_close(MovieReader *anim)
MINLINE void copy_v2_v2(float r[2], const float a[2])
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
void BKE_tracking_stabilization_data_get(MovieClip *clip, int framenr, int width, int height, float translation[2], float *scale, float *angle)
void IMB_cache_free(ImBufCache *cache)
bool BLI_exists(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BKE_movieclip_clear_cache(MovieClip *clip)
static void movieclip_blend_read_data(BlendDataReader *reader, ID *id)
static void movie_clip_foreach_cache(ID *id, IDTypeForeachCacheFunctionCallback function_callback, void *user_data)
bool BKE_movieclip_proxy_enabled(MovieClip *clip)
ImBuf * BKE_tracking_undistort_frame(MovieTracking *tracking, ImBuf *ibuf, int calibration_width, int calibration_height, float overscan)
void(*)(ID *id, const IDCacheKey *cache_key, void **cache_p, uint flags, void *user_data) IDTypeForeachCacheFunctionCallback
ImBuf * BKE_tracking_get_search_imbuf(const ImBuf *ibuf, const MovieTrackingTrack *track, const MovieTrackingMarker *marker, bool anchored, bool disable_channels)
void DEG_debug_print_eval(Depsgraph *depsgraph, const char *function_name, const char *object_name, const void *object_address)
void BKE_color_managed_colorspace_settings_copy(ColorManagedColorspaceSettings *colorspace_settings, const ColorManagedColorspaceSettings *settings)
static void write_movieReconstruction(BlendWriter *writer, MovieTrackingReconstruction *reconstruction)
ImBuf * MOV_decode_frame(MovieReader *anim, int frame_index, IMB_Proxy_Size preview_size)
static void moviecache_keydata(void *userkey, int *framenr, int *proxy, int *render_flags)
ImBuf * BKE_movieclip_get_postprocessed_ibuf(MovieClip *clip, const MovieClipUser *user, MovieClipPostprocFlag postprocess_flag)
bool BLI_path_frame(char *path, size_t path_maxncpy, int frame, int digits) ATTR_NONNULL(1)
static bool need_undistortion_postprocess(const MovieClipUser *user, int clip_flag)
static void movieclip_eval_update_reload(Depsgraph *depsgraph, Main *bmain, MovieClip *clip)
void IMB_refImBuf(ImBuf *ibuf)
ImBufCache * IMB_cache_create(const char *name, int keysize, GHashHashFP hashfp, GHashCmpFP cmpfp)
const char * BKE_main_blendfile_path_from_global()
void IMB_cache_put(ImBufCache *cache, void *userkey, ImBuf *ibuf)
@ MCLIP_PROXY_RENDER_UNDISTORT
@ MCLIP_PROXY_RENDER_USE_FALLBACK_RENDER
static bool has_imbuf_cache(MovieClip *clip, const MovieClipUser *user, int flag)
static void write_movieTracks(BlendWriter *writer, ListBaseT< MovieTrackingTrack > *tracks)
int BLI_open(const char *filepath, int oflag, int pmode) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
@ MCLIP_PROXY_RENDER_SIZE_75
@ MCLIP_PROXY_RENDER_SIZE_25
@ MCLIP_PROXY_RENDER_SIZE_FULL
@ MCLIP_PROXY_RENDER_SIZE_50
@ MCLIP_PROXY_RENDER_SIZE_100
float BKE_movieclip_get_fps(MovieClip *clip)
void BKE_id_blend_write(BlendWriter *writer, ID *id)
static void direct_link_movieTracks(BlendDataReader *reader, ListBaseT< MovieTrackingTrack > *tracksbase)
static void movieclip_open_anim_file(MovieClip *clip)
@ LIB_ID_CREATE_NO_USER_REFCOUNT
void BKE_movieclip_get_size_fl(MovieClip *clip, const MovieClipUser *user, float r_size[2])
ImBuf * IMB_dupImBuf(const ImBuf *ibuf1)
ImBuf * IMB_cache_get(ImBufCache *cache, void *userkey, bool *r_is_cached_empty)
void BKE_tracking_dopesheet_tag_update(MovieTracking *tracking)
static ImBuf * put_stabilized_frame_to_cache(MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf, const int framenr, const MovieClipPostprocFlag postprocess_flag)
static ImBuf * postprocess_frame(MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf, int flag, MovieClipPostprocFlag postprocess_flag)
void * BLI_pophead(ListBase *listbase) ATTR_NONNULL(1)
const char * BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL()
static void detect_clip_source(Main *bmain, MovieClip *clip)
ImBuf * BKE_movieclip_anim_ibuf_for_frame_no_lock(MovieClip *clip, const MovieClipUser *user)
void IMB_cache_cleanup(ImBufCache *cache, bool(cleanup_check_cb)(ImBuf *ibuf, void *userkey, void *userdata), void *userdata)
static ImBuf * movieclip_get_postprocessed_ibuf(MovieClip *clip, const MovieClipUser *user, int flag, MovieClipPostprocFlag postprocess_flag, MovieClipCacheFlag cache_flag)
void GPU_texture_mipmap_mode(gpu::Texture *texture, bool use_mipmap, bool use_filter)
void BKE_movieclip_get_cache_segments(MovieClip *clip, const MovieClipUser *user, int *r_totseg, int **r_points)
static void movie_clip_copy_data(Main *, std::optional< Library * >, ID *id_dst, const ID *id_src, const int flag)
bool IMB_save_image(ImBuf *ibuf, const char *filepath, ImBufFlags flags)
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
static ImBuf * get_imbuf_cache(MovieClip *clip, const MovieClipUser *user, int flag)
void void void const char * BLI_path_basename(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
ImBuf * IMB_load_image_from_filepath(const char *filepath, ImBufFlags flags, ColorManagedColorspaceSettings *colorspace_settings=nullptr)
void BKE_tracking_marker_pattern_minmax(const MovieTrackingMarker *marker, float min[2], float max[2])
MINLINE bool equals_v4v4(const float v1[4], const float v2[4]) ATTR_WARN_UNUSED_RESULT
void BKE_movieclip_get_aspect(MovieClip *clip, float *aspx, float *aspy)
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
static void write_moviePlaneTracks(BlendWriter *writer, ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base)
static void moviecache_prioritydeleter(void *priority_data_v)
void IMB_freeImBuf(ImBuf *ibuf)
void BKE_tracking_disable_channels(ImBuf *ibuf, bool disable_red, bool disable_green, bool disable_blue, bool grayscale)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BKE_tracking_undistort_v2(MovieTracking *tracking, int image_width, int image_height, const float co[2], float r_co[2])
static ImBuf * get_stable_cached_frame(MovieClip *clip, const MovieClipUser *user, ImBuf *reference_ibuf, const int framenr, const MovieClipPostprocFlag postprocess_flag)
static bool moviecache_check_free_proxy(ImBuf *, void *userkey, void *)
BMesh const char void * data
static int rendersize_to_proxy(const MovieClipUser *user, int flag)
static void * moviecache_getprioritydata(void *key_v)
static void movie_clip_free_data(ID *id)
static void direct_link_moviePlaneTracks(BlendDataReader *reader, ListBaseT< MovieTrackingPlaneTrack > *plane_tracks_base)
bool BKE_movieclip_put_frame_if_possible(MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf)
ImBuf * BKE_movieclip_get_stable_ibuf(MovieClip *clip, const MovieClipUser *user, MovieClipPostprocFlag postprocess_flag, float r_loc[2], float *r_scale, float *r_angle)
static void direct_link_movieReconstruction(BlendDataReader *reader, MovieTrackingReconstruction *reconstruction)
void BKE_movieclip_build_proxy_frame_for_ibuf(MovieClip *clip, ImBuf *ibuf, MovieDistortion *distortion, int cfra, const int *build_sizes, int build_count, bool undistorted)
void BKE_tracking_settings_init(MovieTracking *tracking)
ImBuf * BKE_tracking_distortion_exec(MovieDistortion *distortion, MovieTracking *tracking, ImBuf *ibuf, int width, int height, float overscan, bool undistort)
static void movieclip_build_proxy_ibuf(const MovieClip *clip, const ImBuf *ibuf, int cfra, int proxy_render_size, bool undistorted, bool threaded)
void BKE_movieclip_update_scopes(MovieClip *clip, const MovieClipUser *user, MovieClipScopes *scopes)
static bool check_undistortion_cache_flags(const MovieClip *clip)
ImBuf * BKE_movieclip_get_ibuf(MovieClip *clip, const MovieClipUser *user)
MovieReader * openanim(const char *filepath, ImBufFlags ibuf_flags, int streamindex, bool keep_original_colorspace, ColorManagedColorspaceSettings *colorspace_settings)
static ImBuf * movieclip_load_movie_file(MovieClip *clip, const MovieClipUser *user, int framenr, int flag)
static gpu::Texture ** movieclip_get_gputexture_ptr(MovieClip *clip, MovieClipUser *cuser)
void BKE_movieclip_clear_proxy_cache(MovieClip *clip)
@ TRACKING_2D_STABILIZATION
ATTR_WARN_UNUSED_RESULT const size_t num
static void movieclip_calc_length(MovieClip *clip)
static uint movieclip_hashhash(const void *keyv)
void BKE_color_managed_colorspace_settings_init(ColorManagedColorspaceSettings *colorspace_settings)
MovieClip * BKE_movieclip_file_add_exists(Main *bmain, const char *filepath)
MINLINE bool equals_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
static ImBuf * get_undistorted_ibuf(MovieClip *clip, MovieDistortion *distortion, ImBuf *ibuf)
void BKE_movieclip_user_set_frame(MovieClipUser *user, int framenr)
void IMB_cache_set_priority_callback(ImBufCache *cache, ImBufCacheGetPriorityDataFP getprioritydatafp, ImBufCacheGetItemPriorityFP getitempriorityfp, ImBufCachePriorityDeleterFP prioritydeleterfp)
void BLO_read_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size, const int elems=1)
float BKE_movieclip_remap_scene_to_clip_frame(const MovieClip *clip, float framenr)
static int user_frame_to_cache_frame(MovieClip *clip, int framenr)
bool IMB_cache_has_frame(ImBufCache *cache, void *userkey)
static void movieclip_blend_write(BlendWriter *writer, ID *id, const void *id_address)
void IMB_cache_set_getdata_callback(ImBufCache *cache, ImBufCacheGetKeyDataFP getdatafp)
void BKE_tracking_free(MovieTracking *tracking)
int BKE_movieclip_get_duration(MovieClip *clip)
T * DEG_get_original(T *id)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
bool BKE_bpath_foreach_path_fixed_process(BPathForeachPathData *bpath_data, char *path, size_t path_maxncpy)
static void movie_clip_init_data(ID *id)
gpu::Texture * IMB_create_gpu_texture(const char *name, ImBuf *ibuf, GPUTextureCreateFlags flags)
ImBuf * BKE_movieclip_get_ibuf_flag(MovieClip *clip, const MovieClipUser *user, MovieClipFlag flag, MovieClipCacheFlag cache_flag)
static void movie_clip_runtime_reset(MovieClip *clip)
bool IMB_cache_put_if_possible(ImBufCache *cache, void *userkey, ImBuf *ibuf)
void GPU_texture_free(gpu::Texture *texture)
void BKE_movieclip_build_proxy_frame(MovieClip *clip, MovieClipFlag clip_flag, MovieDistortion *distortion, int cfra, const int *build_sizes, int build_count, bool undistorted)
static ImBuf * movieclip_load_sequence_file(MovieClip *clip, const MovieClipUser *user, int framenr, int flag)
float MOV_get_fps(const MovieReader *anim)
static bool put_imbuf_cache(MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf, int flag, bool destructive)
static int moviecache_getitempriority(void *last_userkey_v, void *priority_data_v)
static bool imbufcache_hashcmp(const void *av, const void *bv)
int BLI_path_sequence_decode(const char *path, char *head, size_t head_maxncpy, char *tail, size_t tail_maxncpy, unsigned short *r_digits_len)
void BLI_path_split_dir_file(const char *filepath, char *dir, size_t dir_maxncpy, char *file, size_t file_maxncpy) ATTR_NONNULL(1
static void free_buffers(MovieClip *clip)
ImBuf * BKE_tracking_stabilize_frame(MovieClip *clip, int framenr, ImBuf *ibuf, float translation[2], float *scale, float *angle)
void BLI_path_sequence_encode(char *path, size_t path_maxncpy, const char *head, const char *tail, unsigned short numlen, int pic)
bool BKE_movieclip_has_cached_frame(MovieClip *clip, const MovieClipUser *user)
gpu::Texture * GPU_texture_create_error(int dimension, bool array)
float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr)
void MOV_set_custom_proxy_dir(MovieReader *anim, const char *dir)
MINLINE void copy_v4_v4(float r[4], const float a[4])
static void real_ibuf_size(const MovieClip *clip, const MovieClipUser *user, const ImBuf *ibuf, int *width, int *height)
void BKE_movieclip_eval_update(Depsgraph *depsgraph, Main *bmain, MovieClip *clip)
static int sequence_guess_offset(const char *full_name, int head_len, ushort numlen)
void BKE_movieclip_free_gputexture(MovieClip *clip)
static MovieClip * movieclip_alloc(Main *bmain, const char *name)
ImBuf * IMB_scale_into_new(const ImBuf *ibuf, int2 new_size, IMBScaleFilter filter, bool threaded=true)
bool IMB_scale(ImBuf *ibuf, int2 new_size, IMBScaleFilter filter, bool threaded=true)
static ImBuf * get_postprocessed_cached_frame(const MovieClip *clip, const MovieClipUser *user, int flag, MovieClipPostprocFlag postprocess_flag)
int MOV_get_duration_frames(const MovieReader *anim)
void BLI_thread_unlock(int type)
static int rendersize_to_number(int render_size)
static void movieclip_load_get_size(MovieClip *clip)
gpu::Texture * BKE_movieclip_get_gpu_texture(MovieClip *clip, MovieClipUser *cuser)
MINLINE void zero_v2(float r[2])
void * BKE_id_new(Main *bmain, short type, const char *name)
bool BLI_file_ensure_parent_dir_exists(const char *filepath) ATTR_NONNULL(1)
MovieClip * BKE_movieclip_file_add(Main *bmain, const char *filepath)
MovieClip * BKE_movieclip_file_add_exists_ex(Main *bmain, const char *filepath, bool *r_exists)
char char size_t char * BLI_strncat(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void BLI_thread_lock(int type)
@ MCLIP_USE_PROXY_CUSTOM_DIR
void BKE_movieclip_filepath_for_frame(MovieClip *clip, const MovieClipUser *user, char *filepath)
static void get_sequence_filepath(const MovieClip *clip, const int framenr, char filepath[FILE_MAX])
@ IDTYPE_FLAGS_APPEND_IS_REUSABLE
MovieTrackingMarker * BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void write_pointer_array(int64_t num, const void *data)
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct_array(const int64_t array_size, const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
unsigned int id_session_uid
ImbFormatOptions foptions
const uint8_t * byte_data() const
const float * float_data() const
bool can_contain_alpha() const
ListBaseT< MovieClip > movieclips
MovieClipPostprocFlag flag
MovieClipPostprocFlag postprocess_flag
struct blender::MovieClipCache::@040202166235346345247040047204042373030372021373 postprocessed
struct blender::MovieClipCache::@172310131335001324254172243023316024314303310246 stabilized
struct ImBuf * track_preview
struct MovieTrackingTrack * track
struct MovieTrackingMarker * marker
struct MovieTrackingMarker undist_marker
struct ImBuf * track_search
eMovieClipProxy_RenderFlag render_flag
eMovieClipProxy_RenderSize render_size
gpu::Texture * gputexture
ListBaseT< MovieClip_RuntimeGPUTexture > gputextures
struct MovieReader * anim
struct MovieClipCache * cache
ColorManagedColorspaceSettings colorspace_settings
struct MovieTracking tracking
MovieClip_Runtime runtime
ListBaseT< MovieTrackingDopesheetCoverageSegment > coverage_segments
ListBaseT< MovieTrackingDopesheetChannel > channels
MovieTrackingTrack * active_track
struct MovieReconstructedCamera * cameras
TrackingStabilizationFlag flag
TrackingStabilizationFilter filter
MovieTrackingTrack * rot_track_legacy
struct MovieTrackingTrack * next
MovieTrackingMarker * markers
MovieTrackingStats * stats
MovieTrackingPlaneTrack * act_plane_track_legacy
ListBaseT< MovieTrackingPlaneTrack > plane_tracks_legacy
MovieTrackingCamera camera
MovieTrackingStabilization stabilization
ListBaseT< MovieTrackingTrack > tracks_legacy
MovieTrackingReconstruction reconstruction_legacy
MovieTrackingTrack * act_track_legacy
ListBaseT< MovieTrackingObject > objects
MovieTrackingDopesheet dopesheet