Blender V5.3
sequencer/intern/modifiers/modifier.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2012-2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_array.hh"
10#include "BLI_hash.hh"
11#include "BLI_listbase.hh"
12#include "BLI_rand.hh"
13#include "BLI_set.hh"
14#include "BLI_string_utf8.hh"
15#include "BLI_string_utils.hh"
16#include "BLI_task.hh"
17
18#include "BLT_translation.hh"
19
20#include "DNA_mask_types.h"
21#include "DNA_sequence_types.h"
22#include "DNA_space_types.h"
23
24#include "BKE_colortools.hh"
25#include "BKE_idprop.hh"
26#include "BKE_screen.hh"
27
28#include "RNA_access.hh"
29#include "RNA_prototypes.hh"
30
31#include "SEQ_modifier.hh"
32#include "SEQ_modifiertypes.hh"
33#include "SEQ_render.hh"
34#include "SEQ_select.hh"
35#include "SEQ_sequencer.hh"
36#include "SEQ_utils.hh"
37
38#include "UI_interface.hh"
40
41#include "BLO_read_write.hh"
42
43#include "WM_api.hh"
44
45#include "modifier.hh"
46#include "render.hh"
47
48namespace blender::seq {
49
50/* -------------------------------------------------------------------- */
51
52static bool modifier_has_persistent_uid(const Strip &strip, int uid)
53{
54 for (StripModifierData &smd : strip.modifiers) {
55 if (smd.persistent_uid == uid) {
56 return true;
57 }
58 }
59 return false;
60}
61
63{
66 while (true) {
67 const int new_uid = rng.get_int32();
68 if (new_uid <= 0) {
69 continue;
70 }
71 if (modifier_has_persistent_uid(strip, new_uid)) {
72 continue;
73 }
74 smd.persistent_uid = new_uid;
75 break;
76 }
77}
78
80{
81 Set<int> uids;
82 int modifiers_num = 0;
83 for (StripModifierData &smd : strip.modifiers) {
84 if (smd.persistent_uid <= 0) {
85 return false;
86 }
87 uids.add(smd.persistent_uid);
88 modifiers_num++;
89 }
90 if (uids.size() != modifiers_num) {
91 return false;
92 }
93 return true;
94}
95
96static void modifier_ops_extra_draw(bContext *C, ui::Layout *layout, void *smd_v)
97{
98 Scene *sequencer_scene = CTX_data_sequencer_scene(C);
99 Strip *strip = seq::select_active_get(sequencer_scene);
100 if (!strip) {
101 return;
102 }
103 StripModifierData *smd = static_cast<StripModifierData *>(smd_v);
104 PointerRNA mod_ptr = RNA_pointer_create_discrete(&sequencer_scene->id, RNA_StripModifier, smd);
105
106 PointerRNA op_ptr;
107 /* Duplicate. */
108 op_ptr = layout->op("SEQUENCER_OT_strip_modifier_duplicate",
110 ICON_DUPLICATE);
111 RNA_string_set(&op_ptr, "modifier", smd->name);
112 /* Copy to selected. */
113 op_ptr = layout->op("SEQUENCER_OT_strip_modifier_copy",
114 CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Copy to Selected"),
115 0);
116 RNA_enum_set(&op_ptr, "type", /*SEQ_MODIFIER_COPY_APPEND*/ 1);
117 RNA_string_set(&op_ptr, "modifier", smd->name);
118
119 layout->separator();
120
121 /* Move to first. */
122 {
123 ui::Layout &row = layout->row(false);
124 op_ptr = row.op("SEQUENCER_OT_strip_modifier_move_to_index",
125 IFACE_("Move to First"),
126 ICON_TRIA_UP,
129 RNA_string_set(&op_ptr, "modifier", smd->name);
130 RNA_int_set(&op_ptr, "index", 0);
131 row.enabled_set(smd->prev != nullptr);
132 }
133
134 /* Move to last. */
135 {
136 ui::Layout &row = layout->row(false);
137 op_ptr = row.op("SEQUENCER_OT_strip_modifier_move_to_index",
138 IFACE_("Move to Last"),
139 ICON_TRIA_DOWN,
142 RNA_string_set(&op_ptr, "modifier", smd->name);
143 RNA_int_set(&op_ptr, "index", strip->modifiers.count() - 1);
144 row.enabled_set(smd->next != nullptr);
145 }
146
147 if (smd->type == eSeqModifierType_Compositor) {
148 layout->separator();
149 layout->prop(&mod_ptr, "show_group_selector", UI_ITEM_NONE, std::nullopt, ICON_NONE);
150 }
151}
152
153static void modifier_panel_header(const bContext * /*C*/, Panel *panel)
154{
155 ui::Layout &layout = *panel->layout;
156
157 /* Don't use #modifier_panel_get_property_pointers, we don't want to lock the header. */
159 StripModifierData *smd = static_cast<StripModifierData *>(ptr->data);
160
161 ui::panel_context_pointer_set(panel, "modifier", ptr);
162
163 /* Modifier Icon. */
164 ui::Layout *sub = &layout.row(true);
166 PointerRNA active_op_ptr = sub->op(
167 "SEQUENCER_OT_strip_modifier_set_active", "", RNA_struct_ui_icon(ptr->type));
168 RNA_string_set(&active_op_ptr, "modifier", smd->name);
169
170 ui::Layout &row = layout.row(true);
171
172 /* Modifier Name.
173 * Count how many buttons are added to the header to check if there is enough space. */
174 int buttons_number = 0;
175 ui::Layout &name_row = row.row(true);
176
177 if (!smd->is_type_sound()) {
178 sub = &row.row(true);
179 sub->prop(ptr, "show_preview", UI_ITEM_NONE, "", ICON_NONE);
180 buttons_number++;
181 }
182
183 sub = &row.row(true);
184 sub->prop(ptr, "enable", UI_ITEM_NONE, "", ICON_NONE);
185 buttons_number++;
186
187 /* Extra operators menu. */
188 row.menu_fn("", ICON_DOWNARROW_HLT, modifier_ops_extra_draw, smd);
189
190 /* Delete button. */
191 sub = &row.row(false);
193 PointerRNA remove_op_ptr = sub->op("SEQUENCER_OT_strip_modifier_remove", "", ICON_X);
194 RNA_string_set(&remove_op_ptr, "name", smd->name);
195 buttons_number++;
196
197 bool display_name = (panel->sizex / UI_UNIT_X - buttons_number > 5) || (panel->sizex == 0);
198 if (display_name) {
199 name_row.prop(ptr, "name", UI_ITEM_NONE, "", ICON_NONE);
200 }
201 else {
203 }
204
205 /* Extra padding for delete button. */
206 layout.separator();
207}
208
210{
211 Scene *sequencer_scene = CTX_data_sequencer_scene(C);
212 Editing *ed = seq::editing_get(sequencer_scene);
213
214 const int input_mask_type = RNA_enum_get(ptr, "input_mask_type");
215
216 layout.use_property_split_set(true);
217
218 ui::Layout &col = layout.column(false);
219 ui::Layout *row = &col.row(true);
220 row->prop(ptr, "input_mask_type", ui::ITEM_R_EXPAND, IFACE_("Type"), ICON_NONE);
221
222 if (input_mask_type == STRIP_MASK_INPUT_STRIP) {
223 PointerRNA sequences_object = RNA_pointer_create_discrete(
224 &sequencer_scene->id, RNA_SequenceEditor, ed);
225 col.prop_search(
226 ptr, "input_mask_strip", &sequences_object, "strips_all", IFACE_("Mask"), ICON_NONE);
227 }
228 else {
229 col.prop(ptr, "input_mask_id", UI_ITEM_NONE, std::nullopt, ICON_NONE);
230 row = &col.row(true);
231 row->prop(ptr, "mask_time", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
232 }
233}
234
235bool modifier_ui_poll(const bContext *C, PanelType * /*pt*/)
236{
237 Scene *sequencer_scene = CTX_data_sequencer_scene(C);
238 if (!sequencer_scene) {
239 return false;
240 }
241 Strip *active_strip = seq::select_active_get(sequencer_scene);
242 return active_strip != nullptr;
243}
244
248static void modifier_reorder(bContext *C, Panel *panel, const int new_index)
249{
250 PointerRNA *smd_ptr = ui::panel_custom_data_get(panel);
251 StripModifierData *smd = static_cast<StripModifierData *>(smd_ptr->data);
252
253 wmOperatorType *ot = WM_operatortype_find("SEQUENCER_OT_strip_modifier_move_to_index", false);
255 RNA_string_set(&props_ptr, "modifier", smd->name);
256 RNA_int_set(&props_ptr, "index", new_index);
258 WM_operator_properties_free(&props_ptr);
259}
260
261static short get_strip_modifier_expand_flag(const bContext * /*C*/, Panel *panel)
262{
263 PointerRNA *smd_ptr = ui::panel_custom_data_get(panel);
264 StripModifierData *smd = static_cast<StripModifierData *>(smd_ptr->data);
265 return smd->ui_expand_flag;
266}
267
268static void set_strip_modifier_expand_flag(const bContext * /*C*/, Panel *panel, short expand_flag)
269{
270 PointerRNA *smd_ptr = ui::panel_custom_data_get(panel);
271 StripModifierData *smd = static_cast<StripModifierData *>(smd_ptr->data);
272 smd->ui_expand_flag = expand_flag;
273}
274
276 const eStripModifierType type,
278{
279 PanelType *panel_type = MEM_new_zeroed<PanelType>(__func__);
280
281 modifier_type_panel_id(type, panel_type->idname);
282 STRNCPY_UTF8(panel_type->label, "");
284 STRNCPY_UTF8(panel_type->active_property, "is_active");
285 STRNCPY_UTF8(panel_type->context, "strip_modifier");
286
288 panel_type->draw = draw;
289 panel_type->poll = modifier_ui_poll;
290
291 /* Give the panel the special flag that says it was built here and corresponds to a
292 * modifier rather than a #PanelType. */
294 panel_type->reorder = modifier_reorder;
297
298 BLI_addtail(&region_type->paneltypes, panel_type);
299
300 return panel_type;
301}
302
303/* -------------------------------------------------------------------- */
304
306{
307 float4 res;
309 return res;
310}
311
312float4 load_pixel_premul(const float *ptr)
313{
314 return float4(ptr);
315}
316
318{
320}
321
322void store_pixel_premul(float4 pix, float *ptr)
323{
324 *reinterpret_cast<float4 *>(ptr) = pix;
325}
326
328{
329 float4 res;
330 rgba_uchar_to_float(res, ptr);
331 return res;
332}
333
334float4 load_pixel_raw(const float *ptr)
335{
336 return float4(ptr);
337}
338
340{
341 rgba_float_to_uchar(ptr, pix);
342}
343
344void store_pixel_raw(float4 pix, float *ptr)
345{
346 *reinterpret_cast<float4 *>(ptr) = pix;
347}
348
350 const StripModifierData &smd)
351{
352 ImBuf *mask = nullptr;
353
355 if (smd.mask_strip) {
356 mask = seq_render_strip(&context.render_data,
357 &context.render_state,
358 smd.mask_strip,
359 context.timeline_frame)
360 .image;
361 }
362 }
363 else if (smd.mask_input_type == STRIP_MASK_INPUT_ID) {
364 int frame_offset = 0;
366 frame_offset = context.strip.start;
367 }
368 else if (smd.mask_time == STRIP_MASK_TIME_ABSOLUTE) {
369 frame_offset = smd.mask_id ? smd.mask_id->sfra : 0;
370 }
371
372 /* Note that we do not request mask to be float image: if it is that is
373 * fine, but if it is a byte image then we also just take that without
374 * extra memory allocations or conversions. All modifiers are expected
375 * to handle mask being either type. */
376 mask = seq_render_mask(context.render_data.depsgraph,
377 context.render_data.rectx,
378 context.render_data.recty,
379 smd.mask_id,
380 context.timeline_frame - frame_offset,
381 false);
382 }
383
384 return mask;
385}
386
387/* -------------------------------------------------------------------- */
390
392
394{
395#define INIT_TYPE(typeName) (types[eSeqModifierType_##typeName] = &seqModifierType_##typeName)
396 INIT_TYPE(None);
397 INIT_TYPE(BrightContrast);
398 INIT_TYPE(ColorBalance);
399 INIT_TYPE(Compositor);
401 INIT_TYPE(HueCorrect);
403 INIT_TYPE(SoundEqualizer);
404 INIT_TYPE(Pitch);
405 INIT_TYPE(Echo);
406 INIT_TYPE(Tonemap);
407 INIT_TYPE(WhiteBalance);
408#undef INIT_TYPE
409}
410
415
417{
418 if (type <= 0 || type >= NUM_STRIP_MODIFIER_TYPES) {
419 return nullptr;
420 }
421 return modifiersTypes[type];
422}
423
425{
428
429 smd = static_cast<StripModifierData *>(MEM_new_zeroed(smti->struct_size, "sequence modifier"));
430
431 smd->type = type;
434 smd->runtime = MEM_new<StripModifierDataRuntime>(__func__);
435
436 if (!name || !name[0]) {
438 }
439 else {
440 STRNCPY_UTF8(smd->name, name);
441 }
442
443 BLI_addtail(&strip->modifiers, smd);
444
446 strip->runtime->sound_modifiers_count++;
447 }
448
449 modifier_unique_name(strip, smd);
450
451 if (smti->init_data) {
452 smti->init_data(smd);
453 }
454
455 modifier_set_active(strip, smd);
456
457 return smd;
458}
459
461{
462 if (BLI_findindex(&strip->modifiers, smd) == -1) {
463 return false;
464 }
465
466 if (smd->flag & STRIP_MODIFIER_FLAG_ACTIVE) {
467 /* Prefer the next modifier but use the previous if this modifier is the last in the list. */
468 if (smd->next != nullptr) {
469 modifier_set_active(strip, smd->next);
470 }
471 else if (smd->prev != nullptr) {
472 modifier_set_active(strip, smd->prev);
473 }
474 }
475
476 BLI_remlink(&strip->modifiers, smd);
477 modifier_free(smd);
478
479 return true;
480}
481
483{
484 StripModifierData *smd, *smd_next;
485
486 for (smd = strip->modifiers.first(); smd; smd = smd_next) {
487 smd_next = smd->next;
488 modifier_free(smd);
489 }
490
491 strip->modifiers.clear_no_delete();
492}
493
495{
497
498 if (smti && smti->free_data) {
499 smti->free_data(smd);
500 }
501
502 if (smd->runtime) {
503 MEM_delete(smd->runtime);
504 }
505 if (smd->system_properties != nullptr) {
507 }
508
509 MEM_delete(smd);
510}
511
513{
515
516 BLI_uniquename(&strip->modifiers,
517 smd,
519 '.',
521 sizeof(smd->name));
522}
523
525{
526 return static_cast<StripModifierData *>(
527 BLI_findstring(&(strip->modifiers), name, offsetof(StripModifierData, name)));
528}
529
530static bool skip_modifier(Scene *scene, const StripModifierData *smd, int timeline_frame)
531{
532 using namespace blender::seq;
533
534 if (smd->mask_strip == nullptr) {
535 return false;
536 }
537 const bool strip_has_ended_skip = smd->mask_input_type == STRIP_MASK_INPUT_STRIP &&
539 !smd->mask_strip->intersects_frame(scene, timeline_frame);
540 const bool missing_data_skip = !strip_has_valid_data(smd->mask_strip) ||
542
543 return strip_has_ended_skip || missing_data_skip;
544}
545
547{
548 if (context.strip.modifiers.first() == nullptr) {
549 return;
550 }
551
552 for (StripModifierData &smd : context.strip.modifiers) {
554
555 /* could happen if modifier is being removed or not exists in current version of blender */
556 if (!smti) {
557 continue;
558 }
559
560 const bool show_preview = (smd.flag & STRIP_MODIFIER_FLAG_SHOW_PREVIEW) != 0;
561 const bool show_render = (smd.flag & STRIP_MODIFIER_FLAG_MUTE) == 0;
562
563 if (context.render_data.render && !show_render) {
564 continue;
565 }
566
567 if (!context.render_data.render && !show_preview) {
568 continue;
569 }
570
571 if (smti->apply && !skip_modifier(context.render_data.scene, &smd, context.timeline_frame)) {
572 smti->apply(context, &smd);
573 }
574 }
575}
576
577StripModifierData *modifier_copy(Strip &strip_dst, StripModifierData *mod_src, const int flag)
578{
579 const StripModifierTypeInfo *smti = modifier_type_info_get(mod_src->type);
580 StripModifierData *mod_new = MEM_dupalloc(mod_src);
581
582 mod_new->system_properties = nullptr;
583 if (mod_src->system_properties) {
585 }
586
587 mod_new->runtime = MEM_new<StripModifierDataRuntime>(__func__);
588
589 if (smti && smti->copy_data) {
590 smti->copy_data(mod_new, mod_src);
591 }
592
593 BLI_addtail(&strip_dst.modifiers, mod_new);
594 BLI_uniquename(&strip_dst.modifiers,
595 mod_new,
596 "Strip Modifier",
597 '.',
600 return mod_new;
601}
602
603void modifier_list_copy(Strip *strip_new, Strip *strip, const int flag)
604{
605 for (StripModifierData &smd : strip->modifiers) {
606 modifier_copy(*strip_new, &smd, flag);
607 }
608}
609
611{
612 return (strip->type != STRIP_TYPE_SOUND);
613}
614
615bool modifier_move_to_index(Strip *strip, StripModifierData *smd, const int new_index)
616{
617 const int current_index = BLI_findindex(&strip->modifiers, smd);
618 return BLI_listbase_move_index(&strip->modifiers, current_index, new_index);
619}
620
622{
623 /* In debug mode, check for only one active modifier. */
624#ifndef NDEBUG
625 int active_count = 0;
626 for (StripModifierData &smd : strip->modifiers) {
628 active_count++;
629 }
630 }
631 BLI_assert(ELEM(active_count, 0, 1));
632#endif
633
634 for (StripModifierData &smd : strip->modifiers) {
636 return &smd;
637 }
638 }
639
640 return nullptr;
641}
642
644{
645 for (StripModifierData &smd_iter : strip->modifiers) {
647 }
648
649 if (smd != nullptr) {
650 BLI_assert(BLI_findindex(&strip->modifiers, smd) != -1);
652 }
653}
654
656{
659 r_idname, sizeof(PanelType::idname), STRIP_MODIFIER_TYPE_PANEL_PREFIX, mti->idname);
660}
661
662void foreach_strip_modifier_id(Strip *strip, const FunctionRef<void(ID *)> fn)
663{
664 for (StripModifierData &smd : strip->modifiers) {
665 if (smd.mask_id) {
666 fn(reinterpret_cast<ID *>(smd.mask_id));
667 }
669 auto *modifier_data = reinterpret_cast<SequencerCompositorModifierData *>(&smd);
670 if (modifier_data->node_group) {
671 fn(reinterpret_cast<ID *>(modifier_data->node_group));
672 }
673 }
674 if (smd.system_properties) {
676 fn((ID *)id_prop->data.pointer);
677 });
678 }
679 }
680}
681
683
684/* -------------------------------------------------------------------- */
687
688void modifier_blend_write(BlendWriter *writer, ListBaseT<StripModifierData> *modbase)
689{
690 for (StripModifierData &smd : *modbase) {
691 const StripModifierTypeInfo *smti = modifier_type_info_get(smd.type);
692
693 if (smti) {
694 if (smd.system_properties) {
695 IDP_BlendWrite(writer, smd.system_properties);
696 }
697
698 writer->write_struct_by_name(smti->struct_name, &smd);
699 if (smti->blend_write) {
700 smti->blend_write(writer, &smd);
701 }
702 }
703 else {
704 writer->write_struct(&smd);
705 }
706 }
707}
708
709void modifier_blend_read_data(BlendDataReader *reader, ListBaseT<StripModifierData> *lb)
710{
712 reader, lb, [](const StripModifierData &smd) {
714 return smti ? size_t(smti->struct_size) : sizeof(StripModifierData);
715 });
716
717 for (StripModifierData &smd : *lb) {
720
721 if (smd.mask_strip) {
722 BLO_read_struct(reader, Strip, &smd.mask_strip);
723 }
724
726 if (smti && smti->blend_read) {
727 smti->blend_read(reader, &smd);
728 }
729 smd.runtime = MEM_new<StripModifierDataRuntime>(__func__);
730 }
731}
732
734
735} // namespace blender::seq
#define IDP_BlendDataRead(reader, prop)
#define STRNCPY_UTF8(dst, src)
#define BLI_string_join(...)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_SEQUENCE
#define CTX_IFACE_(context, msgid)
#define BLT_I18NCONTEXT_OPERATOR_DEFAULT
#define CTX_DATA_(context, msgid)
#define IFACE_(msgid)
#define BLT_I18NCONTEXT_DEFAULT_BPYRNA
#define C
Definition RandGen.cpp:29
#define UI_UNIT_X
#define UI_ITEM_NONE
#define ELEM(...)
int64_t size() const
Definition BLI_set.hh:606
bool add(const Key &key)
Definition BLI_set.hh:248
constexpr StringRef()
#define offsetof(t, d)
#define INIT_TYPE(_id_code)
ImBuf * modifier_render_mask_input(const ModifierApplyContext &context, const StripModifierData &smd)
void modifier_list_copy(Strip *strip_new, Strip *strip, const int flag)
void foreach_strip_modifier_id(Strip *strip, const FunctionRef< void(ID *)> fn)
static void modifier_reorder(bContext *C, Panel *panel, const int new_index)
bool modifier_move_to_index(Strip *strip, StripModifierData *smd, const int new_index)
void store_pixel_raw(float4 pix, uchar *ptr)
void modifier_type_panel_id(eStripModifierType type, char *r_idname)
bool media_presence_is_missing(Scene *scene, const Strip *strip)
void modifier_persistent_uid_init(const Strip &strip, StripModifierData &smd)
static void set_strip_modifier_expand_flag(const bContext *, Panel *panel, short expand_flag)
Editing * editing_get(const Scene *scene)
Definition sequencer.cc:304
void modifier_unique_name(Strip *strip, StripModifierData *smd)
SeqResult seq_render_strip(const RenderData *context, SeqRenderState *state, Strip *strip, float timeline_frame)
Definition render.cc:1903
static StripModifierTypeInfo * modifiersTypes[NUM_STRIP_MODIFIER_TYPES]
void store_pixel_premul(float4 pix, uchar *ptr)
StripModifierData * modifier_find_by_name(Strip *strip, const char *name)
Strip * select_active_get(const Scene *scene)
bool strip_has_valid_data(const Strip *strip)
bool modifier_persistent_uids_are_valid(const Strip &strip)
void modifier_free(StripModifierData *smd)
StripModifierData * modifier_copy(Strip &strip_dst, StripModifierData *mod_src, const int flag)
bool modifier_remove(Strip *strip, StripModifierData *smd)
float4 load_pixel_raw(const uchar *ptr)
const StripModifierTypeInfo * modifier_type_info_get(eStripModifierType type)
void modifier_set_active(Strip *strip, StripModifierData *smd)
static void modifier_panel_header(const bContext *, Panel *panel)
static short get_strip_modifier_expand_flag(const bContext *, Panel *panel)
float4 load_pixel_premul(const uchar *ptr)
bool strip_supports_modifiers(const Strip *strip)
static bool skip_modifier(Scene *scene, const StripModifierData *smd, int timeline_frame)
void modifier_apply_stack(ModifierApplyContext &context)
void modifier_blend_read_data(BlendDataReader *reader, ListBaseT< StripModifierData > *lb)
bool modifier_ui_poll(const bContext *C, PanelType *)
StripModifierData * modifier_new(Strip *strip, const char *name, eStripModifierType type)
void(*)(const bContext *, Panel *) PanelDrawFn
Definition modifier.hh:84
void draw_mask_input_type_settings(const bContext *C, ui::Layout &layout, PointerRNA *ptr)
void modifier_blend_write(BlendWriter *writer, ListBaseT< StripModifierData > *modbase)
ImBuf * seq_render_mask(Depsgraph *depsgraph, int width, int height, const Mask *mask, float frame_index, bool make_float)
Definition render.cc:1331
static bool modifier_has_persistent_uid(const Strip &strip, int uid)
static void modifier_types_init(StripModifierTypeInfo *types[])
PanelType * modifier_panel_register(ARegionType *region_type, const eStripModifierType type, PanelDrawFn draw)
StripModifierData * modifier_get_active(const Strip *strip)
static void modifier_ops_extra_draw(bContext *C, ui::Layout *layout, void *smd_v)
void panel_context_pointer_set(Panel *panel, const char *name, PointerRNA *ptr)
PointerRNA * panel_custom_data_get(const Panel *panel)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ UI_PANEL_DATA_EXPAND_ROOT
unsigned __int64 uint64_t
Definition BKE_text.h:91
void IDP_FreeProperty_ex(IDProperty *prop, bool do_id_user)
Definition idprop.cc:1398
MINLINE void rgba_uchar_to_float(float r_col[4], const unsigned char col_ub[4])
int RNA_enum_get(PointerRNA *ptr, const char *name)
Scene * CTX_data_sequencer_scene(const bContext *C)
void WM_operator_properties_free(PointerRNA *ptr)
void RNA_string_set(PointerRNA *ptr, const char *name, const char *value)
void RNA_int_set(PointerRNA *ptr, const char *name, int value)
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
Definition idprop.cc:1696
void IDP_foreach_property(IDProperty *id_property_root, int type_filter, FunctionRef< void(IDProperty *id_property)> callback)
PointerRNA WM_operator_properties_create_ptr(wmOperatorType *ot)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
@ STRIP_MODIFIER_FLAG_EXPANDED
@ STRIP_MODIFIER_FLAG_SHOW_PREVIEW
VecBase< float, 4 > float4
unsigned int uint32_t
Definition BKE_text.h:81
void BLI_uniquename(const ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
unsigned char uchar
Definition BKE_text.h:58
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
bool BLI_listbase_move_index(ListBase *listbase, int from, int to) ATTR_NONNULL()
Definition listbase.cc:474
void BLO_read_struct_list_with_type_size(BlendDataReader *reader, size_t base_size, ListBase *list, FunctionRef< size_t(const void *data)> type_size_fn)
Definition readfile.cc:6591
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
int RNA_struct_ui_icon(const StructRNA *type)
MINLINE void straight_uchar_to_premul_float(float result[4], const unsigned char color[4])
wmOperatorType * WM_operatortype_find(const char *idname, bool quiet)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
@ PANEL_TYPE_HEADER_EXPAND
@ PANEL_TYPE_INSTANCED
wmOperatorStatus WM_operator_name_call_ptr(bContext *C, wmOperatorType *ot, wm::OpCallContext context, PointerRNA *properties, const wmEvent *event)
IDProperty * IDP_CopyProperty_ex(const IDProperty *prop, int flag) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition idprop.cc:968
@ eSeqModifierType_Compositor
MINLINE void premul_float_to_straight_uchar(unsigned char *result, const float color[4])
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
Definition BLI_hash.hh:252
@ IDP_TYPE_FILTER_ID
MINLINE void rgba_float_to_uchar(unsigned char r_col[4], const float col_f[4])
#define hash
Definition noise_c.cc:156
ListBaseT< PanelType > paneltypes
void write_struct_by_name(const char *struct_name, const void *data, BlendStructWriterFn fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void(*) reorder(bContext *C, Panel *pa, int new_index)
char active_property[BKE_ST_MAXNAME]
char translation_context[BKE_ST_MAXNAME]
short(*) get_list_data_expand_flag(const bContext *C, Panel *pa)
char context[BKE_ST_MAXNAME]
void(*) draw(const bContext *C, Panel *panel)
void(*) set_list_data_expand_flag(const bContext *C, Panel *pa, short expand_flag)
bool(*) poll(const bContext *C, PanelType *pt)
void(*) draw_header(const bContext *C, Panel *panel)
char idname[BKE_ST_MAXNAME]
char label[BKE_ST_MAXNAME]
ui::Layout * layout
StructRNA * type
Definition RNA_types.hh:63
struct StripModifierData * prev
struct StripModifierData * next
blender::seq::StripModifierDataRuntime * runtime
struct IDProperty * system_properties
void(*) copy_data(StripModifierData *smd, StripModifierData *target)
void(*) blend_write(BlendWriter *writer, const StripModifierData *smd)
void(*) free_data(StripModifierData *smd)
void(*) init_data(StripModifierData *smd)
void(*) apply(ModifierApplyContext &context, StripModifierData *smd)
void(*) blend_read(BlendDataReader *reader, StripModifierData *smd)
void enabled_set(bool enabled)
void alignment_set(LayoutAlign alignment)
void prop_search(PointerRNA *ptr, PropertyRNA *prop, PointerRNA *searchptr, PropertyRNA *searchprop, PropertyRNA *item_searchpropname, std::optional< StringRefNull > name, int icon, bool results_are_suggestions)
void use_property_split_set(bool is_sep)
PointerRNA op(wmOperatorType *ot, std::optional< StringRef > name, int icon, wm::OpCallContext context, eUI_Item_Flag flag)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
Layout & column(bool align)
void separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
Layout & row(bool align)
void menu_fn(StringRefNull name, int icon, MenuCreateFunc func, void *arg)
void emboss_set(EmbossType emboss)